package com.ksm.tasks;

import java.net.URLDecoder;
import java.net.URLEncoder;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.springframework.stereotype.Component;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.ksm.zyz.controller.SyncClientclasssController;
import com.ksm.zyz.controller.SyncServerclasssController;
import com.ksm.zyz.sys.entity.*;
import com.ksm.zyz.sys.serverentity.*;
import com.ksm.zyz.sys.serverservice.*;
import com.ksm.zyz.sys.service.BaseLadderPriceLogService;
import com.ksm.zyz.sys.service.BaseLadderPriceService;
import com.ksm.zyz.sys.service.BaseMemberdayService;
import com.ksm.zyz.sys.service.BaseMonthlyBalanceService;
import com.ksm.zyz.sys.service.BaseMultiItemService;
import com.ksm.zyz.sys.service.BaseParmInfoService;
import com.ksm.zyz.sys.service.OrderAllotGoodsService;
import com.ksm.zyz.sys.service.OrderAllotInfoService;
import com.ksm.zyz.sys.service.OrderBigsaleGoodsService;
import com.ksm.zyz.sys.service.OrderBigsaleInfoService;
import com.ksm.zyz.sys.service.OrderBreakageGoodsService;
import com.ksm.zyz.sys.service.OrderBreakageInfoService;
import com.ksm.zyz.sys.service.OrderCollectionInfoService;
import com.ksm.zyz.sys.service.OrderCollectionListService;
import com.ksm.zyz.sys.service.OrderDeductmoneyGoodsService;
import com.ksm.zyz.sys.service.OrderDeductmoneyInfoService;
import com.ksm.zyz.sys.service.OrderDelayGoodslistService;
import com.ksm.zyz.sys.service.OrderDelayInfoService;
import com.ksm.zyz.sys.service.OrderFreegoodsInfoService;
import com.ksm.zyz.sys.service.OrderFreegoodsListService;
import com.ksm.zyz.sys.service.OrderHandinInfoService;
import com.ksm.zyz.sys.service.OrderHandinListService;
import com.ksm.zyz.sys.service.OrderInterioruseGoodsService;
import com.ksm.zyz.sys.service.OrderInterioruseInfoService;
import com.ksm.zyz.sys.service.OrderInventoryGoodsService;
import com.ksm.zyz.sys.service.OrderInventoryGroupService;
import com.ksm.zyz.sys.service.OrderInventoryInfoService;
import com.ksm.zyz.sys.service.OrderInventoryPersonService;
import com.ksm.zyz.sys.service.OrderOutstockGoodsService;
import com.ksm.zyz.sys.service.OrderOutstockInfoService;
import com.ksm.zyz.sys.service.OrderPaymentInfoService;
import com.ksm.zyz.sys.service.OrderPaymentListService;
import com.ksm.zyz.sys.service.OrderPoolPaymentInfoService;
import com.ksm.zyz.sys.service.OrderPoolPaymentListService;
import com.ksm.zyz.sys.service.OrderPoolSettlementInfoService;
import com.ksm.zyz.sys.service.OrderPoolSettlementListService;
import com.ksm.zyz.sys.service.OrderProcurementGoodsService;
import com.ksm.zyz.sys.service.OrderProcurementInfoService;
import com.ksm.zyz.sys.service.OrderPurchaseGoodsService;
import com.ksm.zyz.sys.service.OrderPurchaseInfoService;
import com.ksm.zyz.sys.service.OrderReturnGoodslistService;
import com.ksm.zyz.sys.service.OrderReturnInfoService;
import com.ksm.zyz.sys.service.OrderSchargeInfoService;
import com.ksm.zyz.sys.service.OrderSchargeListService;
import com.ksm.zyz.sys.service.OrderSpaymentInfoService;
import com.ksm.zyz.sys.service.OrderSpaymentListService;
import com.ksm.zyz.sys.service.SysAuthorityItemService;
import com.ksm.zyz.sys.service.SysBackupHistoryService;
import com.ksm.zyz.sys.service.SysBusinessTablesService;
import com.ksm.zyz.sys.service.SysCashAuthorityItemService;
import com.ksm.zyz.sys.service.SysCashuserService;
import com.ksm.zyz.sys.service.SysCheckuserInfoService;
import com.ksm.zyz.sys.service.SysFieldNameDefsService;
import com.ksm.zyz.sys.service.SysLogDtlService;
import com.ksm.zyz.sys.service.SysLogFieldsService;
import com.ksm.zyz.sys.service.SysLogService;
import com.ksm.zyz.sys.service.SysLoginCashLogService;
import com.ksm.zyz.sys.service.SysLoginLogService;
import com.ksm.zyz.sys.service.SysModulesService;
import com.ksm.zyz.sys.service.SysMyformActionCustomNameService;
import com.ksm.zyz.sys.service.SysMymenuService;
import com.ksm.zyz.sys.service.SysMyuserGroupReService;
import com.ksm.zyz.sys.service.SysMyuserGroupService;
import com.ksm.zyz.sys.service.SysMyuserRoleService;
import com.ksm.zyz.sys.service.SysMyuserService;
import com.ksm.zyz.sys.service.XinXiBiaoService;
import com.ksm.zyz.sys.service.baseChargeInfoService;
import com.ksm.zyz.sys.service.baseCustomerInfoService;
import com.ksm.zyz.sys.service.baseGoodsInfoService;
import com.ksm.zyz.sys.service.baseGoodsStockService;
import com.ksm.zyz.sys.service.baseGoodsUnitService;
import com.ksm.zyz.sys.service.baseMemberInfoService;
import com.ksm.zyz.sys.service.baseMemberLogService;
import com.ksm.zyz.sys.service.baseScalesInfoService;
import com.ksm.zyz.sys.service.baseShopInfoService;
import com.ksm.zyz.sys.service.baseSpecialPriceLogService;
import com.ksm.zyz.sys.service.baseSpecialPriceService;
import com.ksm.zyz.sys.service.baseSpecialThemeService;
import com.ksm.zyz.sys.service.baseSpecialThemegoodsService;
import com.ksm.zyz.sys.service.baseSupplierInfoService;
import com.ksm.zyz.sys.service.baseSupplierPaytypeService;
import com.ksm.zyz.sys.service.baseTypeInfoService;
import com.ksm.zyz.sys.service.baseValuecardInfoService;
import com.ksm.zyz.sys.service.baseValuecardLogService;
import com.ksm.zyz.sys.service.baseVillageService;
import com.ksm.zyz.sys.service.baseWarehouseInfoService;
import com.ksm.zyz.sys.service.baseWebVillageService;
import com.ksm.zyz.sys.service.mySqlTongbuService;
import com.ksm.zyz.sys.service.orderGoodsInfoService;
import com.ksm.zyz.sys.service.orderGoodsListService;
import com.ksm.zyz.sys.service.orderInstockGoodsService;
import com.ksm.zyz.sys.service.orderInstockInfoService;

@Component("tasksListenTask")
public class TasksListenTask extends QuartzJobBean{
	/**
     * cron表达式：* * * * * *（共6位，使用空格隔开，具体如下）
     * cron表达式：*(秒0-59) *(分钟0-59) *(小时0-23) *(日期1-31) *(月份1-12或是JAN-DEC) *(星期1-7或是SUN-SAT)
     */
	@Autowired
	private mySqlTongbuService mySqlTongbuService;
	@Autowired
	private TongbuService Service;
	@Autowired
	private sXinXiBiaoService xService;
	@Autowired
	private XinXiBiaoService xinxiService;	
	@Autowired
	private sBaseChargeInfoService sBaseChargeInfoService;
	@Autowired
	private baseChargeInfoService BaseChargeInfoService;
	@Autowired
	private sBaseCustomerInfoService sBaseCustomerInfoService;
	@Autowired
	private baseCustomerInfoService BaseCustomerInfoService;
	@Autowired
	private sBaseGoodsInfoService sBaseGoodsInfoService;
	@Autowired
	private baseGoodsInfoService BaseGoodsInfoService;
	@Autowired
	private sBaseGoodsStockService sBaseGoodsStockService;
	@Autowired
	private baseGoodsStockService BaseGoodsStockService;
	@Autowired
	private sBaseGoodsUnitService sBaseGoodsUnitService;
	@Autowired
	private baseGoodsUnitService BaseGoodsUnitService;
	@Autowired
	private sBaseMemberInfoService sBaseMemberInfoService;
	@Autowired
	private baseMemberInfoService BaseMemberInfoService;
	@Autowired
	private sBaseMemberLogService sBaseMemberLogService;
	@Autowired
	private baseMemberLogService BaseMemberLogService;
	@Autowired
	private sBaseScalesInfoService sBaseScalesInfoService;
	@Autowired
	private baseScalesInfoService BaseScalesInfoService;
	@Autowired
	private sBaseShopInfoService sBaseShopInfoService;
	@Autowired
	private baseShopInfoService BaseShopInfoService;
	@Autowired
	private sBaseSpecialPriceLogService sBaseSpecialPriceLogService; //20170325
	@Autowired
	private baseSpecialPriceLogService BaseSpecialPriceLogService;
	@Autowired
	private sBaseSpecialPriceService sBaseSpecialPriceService;
	@Autowired
	private baseSpecialPriceService BaseSpecialPriceService;
	@Autowired
	private sBaseSpecialThemegoodsService sBaseSpecialThemegoodsService;
	@Autowired
	private baseSpecialThemegoodsService BaseSpecialThemegoodsService;
	@Autowired
	private sBaseSpecialThemeService sBaseSpecialThemeService;
	@Autowired
	private baseSpecialThemeService BaseSpecialThemeService;
	@Autowired
	private sBaseSupplierPaytypeService sBaseSupplierPaytypeService;
	@Autowired
	private baseSupplierPaytypeService BaseSupplierPaytypeService;
	@Autowired
	private sBaseTypeInfoService sBaseTypeInfoService;
	@Autowired
	private baseTypeInfoService BaseTypeInfoService;
	@Autowired
	private sBaseValuecardInfoService sBaseValuecardInfoService;
	@Autowired
	private baseValuecardInfoService BaseValuecardInfoService;
	@Autowired
	private sBaseValuecardLogService sBaseValuecardLogService;
	@Autowired
	private baseValuecardLogService BaseValuecardLogService;
	@Autowired
	private sBaseVillageService sBaseVillageService;
	@Autowired
	private baseVillageService BaseVillageService;
	@Autowired
	private sBaseWarehouseInfoService sBaseWarehouseInfoService;
	@Autowired
	private baseWarehouseInfoService BaseWarehouseInfoService;
	@Autowired
	private sBaseWebVillageService sBaseWebVillageService;
	@Autowired
	private baseWebVillageService BaseWebVillageService;
	@Autowired
	private sOrderAllotGoodsService sOrderAllotGoodsService;
	@Autowired
	private OrderAllotGoodsService OrderAllotGoodsService;
	@Autowired
	private sOrderAllotInfoService sOrderAllotInfoService;
	@Autowired
	private OrderAllotInfoService OrderAllotInfoService;
	@Autowired
	private sOrderBigsaleGoodsService sOrderBigsaleGoodsService;
	@Autowired
	private OrderBigsaleGoodsService OrderBigsaleGoodsService;
	@Autowired
	private sOrderBigsaleInfoService sOrderBigsaleInfoService;
	@Autowired
	private OrderBigsaleInfoService OrderBigsaleInfoService;
	@Autowired
	private sOrderBreakageGoodsService sOrderBreakageGoodsService;
	@Autowired
	private OrderBreakageGoodsService OrderBreakageGoodsService;
	@Autowired
	private sOrderBreakageInfoService sOrderBreakageInfoService;
	@Autowired
	private OrderBreakageInfoService OrderBreakageInfoService;
	@Autowired
	private sOrderCollectionInfoService sOrderCollectionInfoService;
	@Autowired
	private OrderCollectionInfoService OrderCollectionInfoService;
	@Autowired
	private sOrderCollectionListService sOrderCollectionListService;
	@Autowired
	private OrderCollectionListService OrderCollectionListService;
	@Autowired
	private sOrderDeductmoneyGoodsService sOrderDeductmoneyGoodsService;
	@Autowired
	private OrderDeductmoneyGoodsService OrderDeductmoneyGoodsService;
	@Autowired
	private sOrderDeductmoneyInfoService sOrderDeductmoneyInfoService;
	@Autowired
	private OrderDeductmoneyInfoService OrderDeductmoneyInfoService;
	@Autowired
	private sOrderDelayGoodslistService sOrderDelayGoodslistService;
	@Autowired
	private OrderDelayGoodslistService OrderDelayGoodslistService;
	@Autowired
	private sOrderDelayInfoService sOrderDelayInfoService;
	@Autowired
	private OrderDelayInfoService OrderDelayInfoService; 
	@Autowired
	private sOrderFreegoodsInfoService sOrderFreegoodsInfoService;
	@Autowired
	private OrderFreegoodsInfoService OrderFreegoodsInfoService;
	@Autowired
	private sOrderFreegoodsListService sOrderFreegoodsListService;
	@Autowired
	private OrderFreegoodsListService OrderFreegoodsListService;
	@Autowired
	private sOrderHandinInfoService sOrderHandinInfoService;
	@Autowired
	private OrderHandinInfoService OrderHandinInfoService;
	@Autowired
	private sOrderHandinListService sOrderHandinListService;
	@Autowired
	private OrderHandinListService OrderHandinListService;
	@Autowired
	private sOrderInterioruseGoodsService sOrderInterioruseGoodsService;
	@Autowired
	private OrderInterioruseGoodsService OrderInterioruseGoodsService;
	@Autowired
	private sOrderInterioruseInfoService sOrderInterioruseInfoService;
	@Autowired
	private OrderInterioruseInfoService OrderInterioruseInfoService;
	@Autowired
	private sOrderInventoryGoodsService sOrderInventoryGoodsService;
	@Autowired
	private OrderInventoryGoodsService OrderInventoryGoodsService;
	@Autowired
	private sOrderInventoryGroupService sOrderInventoryGroupService;
	@Autowired
	private OrderInventoryGroupService OrderInventoryGroupService;
	@Autowired
	private sOrderInventoryInfoService sOrderInventoryInfoService;
	@Autowired
	private OrderInventoryInfoService OrderInventoryInfoService;
	@Autowired
	private sOrderInventoryPersonService sOrderInventoryPersonService;
	@Autowired
	private OrderInventoryPersonService OrderInventoryPersonService;
	@Autowired
	private sOrderOutstockGoodsService sOrderOutstockGoodsService;
	@Autowired
	private OrderOutstockGoodsService OrderOutstockGoodsService;
	@Autowired
	private sOrderOutstockInfoService sOrderOutstockInfoService;
	@Autowired
	private OrderOutstockInfoService OrderOutstockInfoService;
	@Autowired
	private sOrderPaymentInfoService sOrderPaymentInfoService;
	@Autowired
	private OrderPaymentInfoService OrderPaymentInfoService;
	@Autowired
	private sOrderPaymentListService sOrderPaymentListService;
	@Autowired
	private OrderPaymentListService OrderPaymentListService;
	@Autowired
	private sOrderPoolPaymentInfoService sOrderPoolPaymentInfoService;
	@Autowired
	private OrderPoolPaymentInfoService OrderPoolPaymentInfoService;
	@Autowired
	private sOrderPoolPaymentListService sOrderPoolPaymentListService;
	@Autowired
	private OrderPoolPaymentListService OrderPoolPaymentListService;
	@Autowired
	private sOrderPoolSettlementInfoService sOrderPoolSettlementInfoService;
	@Autowired
	private OrderPoolSettlementInfoService OrderPoolSettlementInfoService;
	@Autowired
	private sOrderPoolSettlementListService sOrderPoolSettlementListService;
	@Autowired
	private OrderPoolSettlementListService OrderPoolSettlementListService;
	@Autowired
	private sOrderProcurementGoodsService sOrderProcurementGoodsService;
	@Autowired
	private OrderProcurementGoodsService OrderProcurementGoodsService;
	@Autowired
	private sOrderProcurementInfoService sOrderProcurementInfoService;
	@Autowired
	private OrderProcurementInfoService OrderProcurementInfoService;
	@Autowired
	private sOrderReturnGoodslistService sOrderReturnGoodslistService;
	@Autowired
	private OrderReturnGoodslistService OrderReturnGoodslistService;
	@Autowired
	private sOrderReturnInfoService sOrderReturnInfoService;
	@Autowired
	private OrderReturnInfoService OrderReturnInfoService;
	@Autowired
	private sOrderSchargeInfoService sOrderSchargeInfoService;
	@Autowired
	private OrderSchargeInfoService OrderSchargeInfoService;
	@Autowired
	private sOrderSchargeListService sOrderSchargeListService;
	@Autowired
	private OrderSchargeListService OrderSchargeListService;
	@Autowired
	private sOrderSpaymentListService sOrderSpaymentListService;
	@Autowired
	private OrderSpaymentListService OrderSpaymentListService;
	@Autowired
	private sOrderSpaymentInfoService sOrderSpaymentInfoService;
	@Autowired
	private OrderSpaymentInfoService OrderSpaymentInfoService;
	@Autowired
	private sSysAuthorityItemService sSysAuthorityItemService;
	@Autowired
	private SysAuthorityItemService SysAuthorityItemService;
	@Autowired
	private sSysBackupHistoryService sSysBackupHistoryService;
	@Autowired
	private SysBackupHistoryService SysBackupHistoryService;
	@Autowired
	private sSysBusinessTablesService sSysBusinessTablesService;
	@Autowired
	private SysBusinessTablesService SysBusinessTablesService;
	@Autowired
	private sSysCashAuthorityItemService sSysCashAuthorityItemService;
	@Autowired
	private SysCashAuthorityItemService SysCashAuthorityItemService;
	@Autowired
	private sSysCashuserService sSysCashuserService;
	@Autowired
	private SysCashuserService SysCashuserService;
	@Autowired
	private sSysCheckuserInfoService sSysCheckuserInfoService;
	@Autowired
	private SysCheckuserInfoService SysCheckuserInfoService;
	@Autowired
	private sSysFieldNameDefsService sSysFieldNameDefsService;
	@Autowired
	private SysFieldNameDefsService SysFieldNameDefsService;
	@Autowired
	private sSysLogDtlService sSysLogDtlService;
	@Autowired
	private SysLogDtlService SysLogDtlService;
	@Autowired
	private sSysLogFieldsService sSysLogFieldsService;
	@Autowired
	private SysLogFieldsService SysLogFieldsService;
	@Autowired
	private sSysLoginCashLogService sSysLoginCashLogService;
	@Autowired
	private SysLoginCashLogService SysLoginCashLogService;
	@Autowired
	private sSysLoginLogService sSysLoginLogService;
	@Autowired
	private SysLoginLogService SysLoginLogService;
	@Autowired
	private sSysLogService sSysLogService;
	@Autowired
	private SysLogService SysLogService;
	@Autowired
	private sSysModulesService sSysModulesService;
	@Autowired
	private SysModulesService SysModulesService;
	@Autowired
	private sSysMyformActionCustomNameService sSysMyformActionCustomNameService;
	@Autowired
	private SysMyformActionCustomNameService SysMyformActionCustomNameService;
	@Autowired
	private sSysMymenuService sSysMymenuService;
	@Autowired
	private SysMymenuService SysMymenuService;
	@Autowired
	private sSysMyuserGroupService sSysMyuserGroupService;
	@Autowired
	private SysMyuserGroupService SysMyuserGroupService;
	@Autowired
	private sSysMyuserGroupReService sSysMyuserGroupReService;
	@Autowired
	private SysMyuserGroupReService SysMyuserGroupReService;
	@Autowired
	private sSysMyuserService sSysMyuserService;
	@Autowired
	private SysMyuserService SysMyuserService;
	@Autowired
	private sSysMyuserRoleService sSysMyuserRoleService;
	@Autowired
	private SysMyuserRoleService SysMyuserRoleService;
	@Autowired
	private sBaseLadderPriceLogService sbaseLadderPriceLogService;
	@Autowired
	private BaseLadderPriceLogService baseLadderPriceLogService;
	@Autowired
	private sBaseLadderPriceService sBaseLadderPriceService;
	@Autowired
	private BaseLadderPriceService BaseLadderPriceService;
	@Autowired
	private sBaseMemberdayService sbaseMemberdayService;
	@Autowired
	private BaseMemberdayService baseMemberdayService;
	@Autowired
	private sBaseMonthlyBalanceService sBaseMonthlyBalanceService;
	@Autowired
	private BaseMonthlyBalanceService BaseMonthlyBalanceService;
	@Autowired
	private sBaseMultiItemService sBaseMultiItemService;
	@Autowired
	private BaseMultiItemService BaseMultiItemService;
	@Autowired
	private sBaseParmInfoService sBaseParmInfoService;
	@Autowired
	private BaseParmInfoService BaseParmInfoService;
	@Autowired
	private sOrderGoodsInfoService sOrderGoodsInfoService;
	@Autowired
	private orderGoodsInfoService orderGoodsInfoService;
	@Autowired
	private sOrderGoodsListService sOrderGoodsListService;
	@Autowired
	private orderGoodsListService orderGoodsListService;
	@Autowired
	private sOrderInstockGoodsService sOrderInstockGoodsService;
	@Autowired
	private orderInstockGoodsService orderInstockGoodsService;
	@Autowired
	private sOrderInstockInfoService sOrderInstockInfoService;
	@Autowired
	private orderInstockInfoService orderInstockInfoService;
	@Autowired
	private sBaseSupplierInfoService sBaseSupplierInfoService;
	@Autowired
	private baseSupplierInfoService BaseSupplierInfoService;
	@Autowired
	private sOrderPurchaseInfoService sOrderPurchaseInfoService;
	@Autowired
	private OrderPurchaseInfoService OrderPurchaseInfoService;
	@Autowired
	private sOrderPurchaseGoodsService sOrderPurchaseGoodsService;
	@Autowired
	private OrderPurchaseGoodsService OrderPurchaseGoodsService;
	@Autowired
	private sBasePromotionInfoLogService sBasePromotionInfoLogService;
	@Autowired
	private sBasePromotionInfoService sBasePromotionInfoService;
	@Autowired
	private sBaseVouchersLogService sBaseVouchersLogService;
	@Autowired
	private sBaseVouchersService sBaseVouchersService;
	@Autowired
	private sDailyGoodsInfoService sDailyGoodsInfoService;
	@Autowired
	private sDailyGoodstypeInfoService sDailyGoodstypeInfoService;
	@Autowired
	private sDailySaleamountInfoService sDailySaleamountInfoService;
	@Autowired
	private sDailySuppliersaleInfoService sDailySuppliersaleInfoService;
	@Autowired
	private sMonlyGoodsInfoService sMonlyGoodsInfoService;
	@Autowired
	private sMonlyGoodsTypeService sMonlyGoodsTypeService;
	@Autowired
	private sMonlySaleamountInfoService sMonlySaleamountInfoService;
	@Autowired
	private sMonlySuppliersaleInfoService sMonlySuppliersaleInfoService;
	@Autowired
	private sOrderInstockModifyLogService sOrderInstockModifyLogService;
	@Autowired
	private sZjilubiaoService sZjilubiaoService;

	//静态变量
	public static final int biaozhi=1;
	@Override
	protected void executeInternal(JobExecutionContext arg0) throws JobExecutionException {
		try{
   xinXibiao xinxi=xService.selectXinxi();
		
		if(xinxi.getNetUid()==null)
		{
		   System.out.println("不能进行数据同步,没有进行网上注册");
		}
		else
		{
			 //FIXME 
	    int ming=xinxi.getNetUid();
	   
	   // System.out.println("@!#$%^&^%%$#@!#"+ming);
	  // 数据包的封装
		 // 分为  添加数据 删除 数据  和修改数据
		 // 例：//map("insert",insertmap<"orderGoodsInfo",List<orderGoodsInfo>>)
		 
		 
		 Map<String,List> insertmap=new HashMap<String,List>();
		 Map<String,List> deletemap=new HashMap<String,List>();
		 Map<String,List> updatemap=new HashMap<String,List>();
		//region   list<对象名>
		 //orderGoodsInfo
		 List<orderGoodsInfo> insertorderGoodsInfolist=new ArrayList<orderGoodsInfo>();
		 List<orderGoodsInfo> deleteorderGoodsInfolist=new ArrayList<orderGoodsInfo>();
		 List<orderGoodsInfo> updateorderGoodsInfolist=new ArrayList<orderGoodsInfo>();
		 //OrderGoodsList
		 List<OrderGoodsList> insertOrderGoodsListlist=new ArrayList<OrderGoodsList>();
		 List<OrderGoodsList> deleteOrderGoodsListlist=new ArrayList<OrderGoodsList>();
		 List<OrderGoodsList> updateOrderGoodsListlist=new ArrayList<OrderGoodsList>();
		 //BaseChargeInfo
		 List<BaseChargeInfo> insertBaseChargeInfolist=new ArrayList<BaseChargeInfo>();
		 List<BaseChargeInfo> deleteBaseChargeInfolist=new ArrayList<BaseChargeInfo>();
		 List<BaseChargeInfo> updateBaseChargeInfolist=new ArrayList<BaseChargeInfo>();
		 //BaseCustomerInfo
		 List<BaseCustomerInfo> insertBaseCustomerInfolist=new ArrayList<BaseCustomerInfo>();
		 List<BaseCustomerInfo> deleteBaseCustomerInfolist=new ArrayList<BaseCustomerInfo>();
		 List<BaseCustomerInfo> updateBaseCustomerInfolist=new ArrayList<BaseCustomerInfo>();
		//BaseGoodsInfo
		 List<BaseGoodsInfo> insertBaseGoodsInfolist=new ArrayList<BaseGoodsInfo>();
		 List<BaseGoodsInfo> deleteBaseGoodsInfolist=new ArrayList<BaseGoodsInfo>();
		 List<BaseGoodsInfo> updateBaseGoodsInfolist=new ArrayList<BaseGoodsInfo>();
		 //BaseGoodsStock
		 List<BaseGoodsStock> insertBaseGoodsStocklist=new ArrayList<BaseGoodsStock>();
		 List<BaseGoodsStock> deleteBaseGoodsStocklist=new ArrayList<BaseGoodsStock>();
		 List<BaseGoodsStock> updateBaseGoodsStocklist=new ArrayList<BaseGoodsStock>();
		 //BaseGoodsUnit
		 List<BaseGoodsUnit> insertBaseGoodsUnitlist=new ArrayList<BaseGoodsUnit>();
		 List<BaseGoodsUnit> deleteBaseGoodsUnitlist=new ArrayList<BaseGoodsUnit>();
		 List<BaseGoodsUnit> updateBaseGoodsUnitlist=new ArrayList<BaseGoodsUnit>();
		 //BaseMemberInfo
		 List<BaseMemberInfo> insertBaseMemberInfolist=new ArrayList<BaseMemberInfo>();
		 List<BaseMemberInfo> deleteBaseMemberInfolist=new ArrayList<BaseMemberInfo>();
		 List<BaseMemberInfo> updateBaseMemberInfolist=new ArrayList<BaseMemberInfo>();
		 //BaseMemberLog
		 List<BaseMemberLog> insertBaseMemberLoglist=new ArrayList<BaseMemberLog>();
		 List<BaseMemberLog> deleteBaseMemberLoglist=new ArrayList<BaseMemberLog>();
		 List<BaseMemberLog> updateBaseMemberLoglist=new ArrayList<BaseMemberLog>();
		 //BaseScalesInfo
		 List<BaseScalesInfo> insertBaseScalesInfolist=new ArrayList<BaseScalesInfo>();
		 List<BaseScalesInfo> deleteBaseScalesInfolist=new ArrayList<BaseScalesInfo>();
		 List<BaseScalesInfo> updateBaseScalesInfolist=new ArrayList<BaseScalesInfo>();
		 //BaseShopInfo
		 List<BaseShopInfo> insertBaseShopInfolist=new ArrayList<BaseShopInfo>();
		 List<BaseShopInfo> deleteBaseShopInfolist=new ArrayList<BaseShopInfo>();
		 List<BaseShopInfo> updateBaseShopInfolist=new ArrayList<BaseShopInfo>();
		 //BaseSpecialPriceLog
		 List<BaseSpecialPriceLog> insertBaseSpecialPriceLoglist=new ArrayList<BaseSpecialPriceLog>();
		 List<BaseSpecialPriceLog> deleteBaseSpecialPriceLoglist=new ArrayList<BaseSpecialPriceLog>();
		 List<BaseSpecialPriceLog> updateBaseSpecialPriceLoglist=new ArrayList<BaseSpecialPriceLog>();
		 //BaseSpecialPrice
		 List<BaseSpecialPrice> insertBaseSpecialPricelist=new ArrayList<BaseSpecialPrice>();
		 List<BaseSpecialPrice> deleteBaseSpecialPricelist=new ArrayList<BaseSpecialPrice>();
		 List<BaseSpecialPrice> updateBaseSpecialPricelist=new ArrayList<BaseSpecialPrice>();
		 //BaseSpecialThemegoods
		 List<BaseSpecialThemegoods> insertBaseSpecialThemegoodslist=new ArrayList<BaseSpecialThemegoods>();
		 List<BaseSpecialThemegoods> deleteBaseSpecialThemegoodslist=new ArrayList<BaseSpecialThemegoods>();
		 List<BaseSpecialThemegoods> updateBaseSpecialThemegoodslist=new ArrayList<BaseSpecialThemegoods>();
		 //BaseSpecialTheme
		 List<BaseSpecialTheme> insertBaseSpecialThemelist=new ArrayList<BaseSpecialTheme>();
		 List<BaseSpecialTheme> deleteBaseSpecialThemelist=new ArrayList<BaseSpecialTheme>();
		 List<BaseSpecialTheme> updateBaseSpecialThemelist=new ArrayList<BaseSpecialTheme>();
		 //BaseSupplierPaytype
		 List<BaseSupplierPaytype> insertBaseSupplierPaytypelist=new ArrayList<BaseSupplierPaytype>();
		 List<BaseSupplierPaytype> deleteBaseSupplierPaytypelist=new ArrayList<BaseSupplierPaytype>();
		 List<BaseSupplierPaytype> updateBaseSupplierPaytypelist=new ArrayList<BaseSupplierPaytype>();
		 //BaseTypeInfo
		 List<BaseTypeInfo> insertBaseTypeInfolist=new ArrayList<BaseTypeInfo>();
		 List<BaseTypeInfo> deleteBaseTypeInfolist=new ArrayList<BaseTypeInfo>();
		 List<BaseTypeInfo> updateBaseTypeInfolist=new ArrayList<BaseTypeInfo>();
		 //BaseValuecardInfo
		 List<BaseValuecardInfo> insertBaseValuecardInfolist=new ArrayList<BaseValuecardInfo>();
		 List<BaseValuecardInfo> deleteBaseValuecardInfolist=new ArrayList<BaseValuecardInfo>();
		 List<BaseValuecardInfo> updateBaseValuecardInfolist=new ArrayList<BaseValuecardInfo>();
		 //BaseValuecardLog
		 List<BaseValuecardLog> insertBaseValuecardLoglist=new ArrayList<BaseValuecardLog>();
		 List<BaseValuecardLog> deleteBaseValuecardLoglist=new ArrayList<BaseValuecardLog>();
		 List<BaseValuecardLog> updateBaseValuecardLoglist=new ArrayList<BaseValuecardLog>();
		 //BaseVillage
		 List<BaseVillage> insertBaseVillagelist=new ArrayList<BaseVillage>();
		 List<BaseVillage> deleteBaseVillagelist=new ArrayList<BaseVillage>();
		 List<BaseVillage> updateBaseVillagelist=new ArrayList<BaseVillage>();
		 //BaseWarehouseInfo
		 List<BaseWarehouseInfo> insertBaseWarehouseInfolist=new ArrayList<BaseWarehouseInfo>();
		 List<BaseWarehouseInfo> deleteBaseWarehouseInfolist=new ArrayList<BaseWarehouseInfo>();
		 List<BaseWarehouseInfo> updateBaseWarehouseInfolist=new ArrayList<BaseWarehouseInfo>();
		 //BaseWebVillage
		 List<BaseWebVillage> insertBaseWebVillagelist=new ArrayList<BaseWebVillage>();
		 List<BaseWebVillage> deleteBaseWebVillagelist=new ArrayList<BaseWebVillage>();
		 List<BaseWebVillage> updateBaseWebVillagelist=new ArrayList<BaseWebVillage>();
		 //OrderAllotGoods
		 List<OrderAllotGoods> insertOrderAllotGoodslist=new ArrayList<OrderAllotGoods>();
		 List<OrderAllotGoods> deleteOrderAllotGoodslist=new ArrayList<OrderAllotGoods>();
		 List<OrderAllotGoods> updateOrderAllotGoodslist=new ArrayList<OrderAllotGoods>();
		 //OrderAllotInfo
		 List<OrderAllotInfo> insertOrderAllotInfolist=new ArrayList<OrderAllotInfo>();
		 List<OrderAllotInfo> deleteOrderAllotInfolist=new ArrayList<OrderAllotInfo>();
		 List<OrderAllotInfo> updateOrderAllotInfolist=new ArrayList<OrderAllotInfo>();
		 //OrderBigsaleGoods
		 List<OrderBigsaleGoods> insertOrderBigsaleGoodslist=new ArrayList<OrderBigsaleGoods>();
		 List<OrderBigsaleGoods> deleteOrderBigsaleGoodslist=new ArrayList<OrderBigsaleGoods>();
		 List<OrderBigsaleGoods> updateOrderBigsaleGoodslist=new ArrayList<OrderBigsaleGoods>();
		 //OrderBigsaleInfo
		 List<OrderBigsaleInfo> insertOrderBigsaleInfolist=new ArrayList<OrderBigsaleInfo>();
		 List<OrderBigsaleInfo> deleteOrderBigsaleInfolist=new ArrayList<OrderBigsaleInfo>();
		 List<OrderBigsaleInfo> updateOrderBigsaleInfolist=new ArrayList<OrderBigsaleInfo>();
		 //OrderBreakageGoods
		 List<OrderBreakageGoods> insertOrderBreakageGoodslist=new ArrayList<OrderBreakageGoods>();
		 List<OrderBreakageGoods> deleteOrderBreakageGoodslist=new ArrayList<OrderBreakageGoods>();
		 List<OrderBreakageGoods> updateOrderBreakageGoodslist=new ArrayList<OrderBreakageGoods>();
		 //OrderBreakageInfo
		 List<OrderBreakageInfo> insertOrderBreakageInfolist=new ArrayList<OrderBreakageInfo>();
		 List<OrderBreakageInfo> deleteOrderBreakageInfolist=new ArrayList<OrderBreakageInfo>();
		 List<OrderBreakageInfo> updateOrderBreakageInfolist=new ArrayList<OrderBreakageInfo>();
		 //OrderCollectionInfo
		 List<OrderCollectionInfo> insertOrderCollectionInfolist=new ArrayList<OrderCollectionInfo>();
		 List<OrderCollectionInfo> deleteOrderCollectionInfolist=new ArrayList<OrderCollectionInfo>();
		 List<OrderCollectionInfo> updateOrderCollectionInfolist=new ArrayList<OrderCollectionInfo>();
		 //OrderCollectionList
		 List<OrderCollectionList> insertOrderCollectionListlist=new ArrayList<OrderCollectionList>();
		 List<OrderCollectionList> deleteOrderCollectionListlist=new ArrayList<OrderCollectionList>();
		 List<OrderCollectionList> updateOrderCollectionListlist=new ArrayList<OrderCollectionList>();
		 //OrderDeductmoneyGoods
		 List<OrderDeductmoneyGoods> insertOrderDeductmoneyGoodslist=new ArrayList<OrderDeductmoneyGoods>();
		 List<OrderDeductmoneyGoods> deleteOrderDeductmoneyGoodslist=new ArrayList<OrderDeductmoneyGoods>();
		 List<OrderDeductmoneyGoods> updateOrderDeductmoneyGoodslist=new ArrayList<OrderDeductmoneyGoods>();
		 //OrderDeductmoneyInfo
		 List<OrderDeductmoneyInfo> insertOrderDeductmoneyInfolist=new ArrayList<OrderDeductmoneyInfo>();
		 List<OrderDeductmoneyInfo> deleteOrderDeductmoneyInfolist=new ArrayList<OrderDeductmoneyInfo>();
		 List<OrderDeductmoneyInfo> updateOrderDeductmoneyInfolist=new ArrayList<OrderDeductmoneyInfo>();
		 //OrderDelayGoodslist
		 List<OrderDelayGoodslist> insertOrderDelayGoodslistlist=new ArrayList<OrderDelayGoodslist>();
		 List<OrderDelayGoodslist> deleteOrderDelayGoodslistlist=new ArrayList<OrderDelayGoodslist>();
		 List<OrderDelayGoodslist> updateOrderDelayGoodslistlist=new ArrayList<OrderDelayGoodslist>();
		 //OrderDelayInfo
		 List<OrderDelayInfo> insertOrderDelayInfolist=new ArrayList<OrderDelayInfo>();
		 List<OrderDelayInfo> deleteOrderDelayInfolist=new ArrayList<OrderDelayInfo>();
		 List<OrderDelayInfo> updateOrderDelayInfolist=new ArrayList<OrderDelayInfo>();
		 //OrderFreegoodsInfo
		 List<OrderFreegoodsInfo> insertOrderFreegoodsInfolist=new ArrayList<OrderFreegoodsInfo>();
		 List<OrderFreegoodsInfo> deleteOrderFreegoodsInfolist=new ArrayList<OrderFreegoodsInfo>();
		 List<OrderFreegoodsInfo> updateOrderFreegoodsInfolist=new ArrayList<OrderFreegoodsInfo>();
		 //OrderFreegoodsList
		 List<OrderFreegoodsList> insertOrderFreegoodsListlist=new ArrayList<OrderFreegoodsList>();
		 List<OrderFreegoodsList> deleteOrderFreegoodsListlist=new ArrayList<OrderFreegoodsList>();
		 List<OrderFreegoodsList> updateOrderFreegoodsListlist=new ArrayList<OrderFreegoodsList>();
		 //OrderHandinInfo
		 List<OrderHandinInfo> insertOrderHandinInfolist=new ArrayList<OrderHandinInfo>();
		 List<OrderHandinInfo> deleteOrderHandinInfolist=new ArrayList<OrderHandinInfo>();
		 List<OrderHandinInfo> updateOrderHandinInfolist=new ArrayList<OrderHandinInfo>();
		 //OrderHandinList
		 List<OrderHandinList> insertOrderHandinListlist=new ArrayList<OrderHandinList>();
		 List<OrderHandinList> deleteOrderHandinListlist=new ArrayList<OrderHandinList>();
		 List<OrderHandinList> updateOrderHandinListlist=new ArrayList<OrderHandinList>();
		 //OrderInterioruseGoods
		 List<OrderInterioruseGoods> insertOrderInterioruseGoodslist=new ArrayList<OrderInterioruseGoods>();
		 List<OrderInterioruseGoods> deleteOrderInterioruseGoodslist=new ArrayList<OrderInterioruseGoods>();
		 List<OrderInterioruseGoods> updateOrderInterioruseGoodslist=new ArrayList<OrderInterioruseGoods>();
		 //OrderInterioruseInfo
		 List<OrderInterioruseInfo> insertOrderInterioruseInfolist=new ArrayList<OrderInterioruseInfo>();
		 List<OrderInterioruseInfo> deleteOrderInterioruseInfolist=new ArrayList<OrderInterioruseInfo>();
		 List<OrderInterioruseInfo> updateOrderInterioruseInfolist=new ArrayList<OrderInterioruseInfo>();
		 //OrderInventoryGoods
		 List<OrderInventoryGoods> insertOrderInventoryGoodslist=new ArrayList<OrderInventoryGoods>();
		 List<OrderInventoryGoods> deleteOrderInventoryGoodslist=new ArrayList<OrderInventoryGoods>();
		 List<OrderInventoryGoods> updateOrderInventoryGoodslist=new ArrayList<OrderInventoryGoods>();
		 //OrderInventoryGroup
		 List<OrderInventoryGroup> insertOrderInventoryGrouplist=new ArrayList<OrderInventoryGroup>();
		 List<OrderInventoryGroup> deleteOrderInventoryGrouplist=new ArrayList<OrderInventoryGroup>();
		 List<OrderInventoryGroup> updateOrderInventoryGrouplist=new ArrayList<OrderInventoryGroup>();
		 //OrderInventoryInfo
		 List<OrderInventoryInfo> insertOrderInventoryInfolist=new ArrayList<OrderInventoryInfo>();
		 List<OrderInventoryInfo> deleteOrderInventoryInfolist=new ArrayList<OrderInventoryInfo>();
		 List<OrderInventoryInfo> updateOrderInventoryInfolist=new ArrayList<OrderInventoryInfo>();
		 //OrderInventoryPerson
		 List<OrderInventoryPerson> insertOrderInventoryPersonlist=new ArrayList<OrderInventoryPerson>();
		 List<OrderInventoryPerson> deleteOrderInventoryPersonlist=new ArrayList<OrderInventoryPerson>();
		 List<OrderInventoryPerson> updateOrderInventoryPersonlist=new ArrayList<OrderInventoryPerson>();
		 //OrderOutstockGoods
		 List<OrderOutstockGoods> insertOrderOutstockGoodslist=new ArrayList<OrderOutstockGoods>();
		 List<OrderOutstockGoods> deleteOrderOutstockGoodslist=new ArrayList<OrderOutstockGoods>();
		 List<OrderOutstockGoods> updateOrderOutstockGoodslist=new ArrayList<OrderOutstockGoods>();
		 //OrderOutstockInfo
		 List<OrderOutstockInfo> insertOrderOutstockInfolist=new ArrayList<OrderOutstockInfo>();
		 List<OrderOutstockInfo> deleteOrderOutstockInfolist=new ArrayList<OrderOutstockInfo>();
		 List<OrderOutstockInfo> updateOrderOutstockInfolist=new ArrayList<OrderOutstockInfo>();
		 //OrderPaymentInfo
		 List<OrderPaymentInfo> insertOrderPaymentInfolist=new ArrayList<OrderPaymentInfo>();
		 List<OrderPaymentInfo> deleteOrderPaymentInfolist=new ArrayList<OrderPaymentInfo>();
		 List<OrderPaymentInfo> updateOrderPaymentInfolist=new ArrayList<OrderPaymentInfo>();
		 //OrderPaymentList
		 List<OrderPaymentList> insertOrderPaymentListlist=new ArrayList<OrderPaymentList>();
		 List<OrderPaymentList> deleteOrderPaymentListlist=new ArrayList<OrderPaymentList>();
		 List<OrderPaymentList> updateOrderPaymentListlist=new ArrayList<OrderPaymentList>();
		 //OrderPoolPaymentInfo
		 List<OrderPoolPaymentInfo> insertOrderPoolPaymentInfolist=new ArrayList<OrderPoolPaymentInfo>();
		 List<OrderPoolPaymentInfo> deleteOrderPoolPaymentInfolist=new ArrayList<OrderPoolPaymentInfo>();
		 List<OrderPoolPaymentInfo> updateOrderPoolPaymentInfolist=new ArrayList<OrderPoolPaymentInfo>();
		 //OrderPoolPaymentList
		 List<OrderPoolPaymentList> insertOrderPoolPaymentListlist=new ArrayList<OrderPoolPaymentList>();
		 List<OrderPoolPaymentList> deleteOrderPoolPaymentListlist=new ArrayList<OrderPoolPaymentList>();
		 List<OrderPoolPaymentList> updateOrderPoolPaymentListlist=new ArrayList<OrderPoolPaymentList>();
		 //OrderPoolSettlementInfo
		 List<OrderPoolSettlementInfo> insertOrderPoolSettlementInfolist=new ArrayList<OrderPoolSettlementInfo>();
		 List<OrderPoolSettlementInfo> deleteOrderPoolSettlementInfolist=new ArrayList<OrderPoolSettlementInfo>();
		 List<OrderPoolSettlementInfo> updateOrderPoolSettlementInfolist=new ArrayList<OrderPoolSettlementInfo>();
		 //OrderProcurementGoods
		 List<OrderProcurementGoods> insertOrderProcurementGoodslist=new ArrayList<OrderProcurementGoods>();
		 List<OrderProcurementGoods> deleteOrderProcurementGoodslist=new ArrayList<OrderProcurementGoods>();
		 List<OrderProcurementGoods> updateOrderProcurementGoodslist=new ArrayList<OrderProcurementGoods>();
		 //OrderProcurementInfo
		 List<OrderProcurementInfo> insertOrderProcurementInfolist=new ArrayList<OrderProcurementInfo>();
		 List<OrderProcurementInfo> deleteOrderProcurementInfolist=new ArrayList<OrderProcurementInfo>();
		 List<OrderProcurementInfo> updateOrderProcurementInfolist=new ArrayList<OrderProcurementInfo>();
		 //OrderReturnGoodslist
		 List<OrderReturnGoodslist> insertOrderReturnGoodslistlist=new ArrayList<OrderReturnGoodslist>();
		 List<OrderReturnGoodslist> deleteOrderReturnGoodslistlist=new ArrayList<OrderReturnGoodslist>();
		 List<OrderReturnGoodslist> updateOrderReturnGoodslistlist=new ArrayList<OrderReturnGoodslist>();
		 //OrderReturnInfo
		 List<OrderReturnInfo> insertOrderReturnInfolist=new ArrayList<OrderReturnInfo>();
		 List<OrderReturnInfo> deleteOrderReturnInfolist=new ArrayList<OrderReturnInfo>();
		 List<OrderReturnInfo> updateOrderReturnInfolist=new ArrayList<OrderReturnInfo>();
		 //OrderSchargeInfo
		 List<OrderSchargeInfo> insertOrderSchargeInfolist=new ArrayList<OrderSchargeInfo>();
		 List<OrderSchargeInfo> deleteOrderSchargeInfolist=new ArrayList<OrderSchargeInfo>();
		 List<OrderSchargeInfo> updateOrderSchargeInfolist=new ArrayList<OrderSchargeInfo>();
		 //OrderSchargeList
		 List<OrderSchargeList> insertOrderSchargeListlist=new ArrayList<OrderSchargeList>();
		 List<OrderSchargeList> deleteOrderSchargeListlist=new ArrayList<OrderSchargeList>();
		 List<OrderSchargeList> updateOrderSchargeListlist=new ArrayList<OrderSchargeList>();
		 //OrderSpaymentInfo
		 List<OrderSpaymentInfo> insertOrderSpaymentInfolist=new ArrayList<OrderSpaymentInfo>();
		 List<OrderSpaymentInfo> deleteOrderSpaymentInfolist=new ArrayList<OrderSpaymentInfo>();
		 List<OrderSpaymentInfo> updateOrderSpaymentInfolist=new ArrayList<OrderSpaymentInfo>();
		 //OrderSpaymentList
		 List<OrderSpaymentList> insertOrderSpaymentListlist=new ArrayList<OrderSpaymentList>();
		 List<OrderSpaymentList> deleteOrderSpaymentListlist=new ArrayList<OrderSpaymentList>();
		 List<OrderSpaymentList> updateOrderSpaymentListlist=new ArrayList<OrderSpaymentList>();
		 //SysAuthorityItem
		 List<SysAuthorityItem> insertSysAuthorityItemlist=new ArrayList<SysAuthorityItem>();
		 List<SysAuthorityItem> deleteSysAuthorityItemlist=new ArrayList<SysAuthorityItem>();
		 List<SysAuthorityItem> updateSysAuthorityItemlist=new ArrayList<SysAuthorityItem>();
		 //SysBackupHistory
		 List<SysBackupHistory> insertSysBackupHistorylist=new ArrayList<SysBackupHistory>();
		 List<SysBackupHistory> deleteSysBackupHistorylist=new ArrayList<SysBackupHistory>();
		 List<SysBackupHistory> updateSysBackupHistorylist=new ArrayList<SysBackupHistory>();
		 //SysBusinessTables
		 List<SysBusinessTables> insertSysBusinessTableslist=new ArrayList<SysBusinessTables>();
		 List<SysBusinessTables> deleteSysBusinessTableslist=new ArrayList<SysBusinessTables>();
		 List<SysBusinessTables> updateSysBusinessTableslist=new ArrayList<SysBusinessTables>();
		 //SysCashAuthorityItem
		 List<SysCashAuthorityItem> insertSysCashAuthorityItemlist=new ArrayList<SysCashAuthorityItem>();
		 List<SysCashAuthorityItem> deleteSysCashAuthorityItemlist=new ArrayList<SysCashAuthorityItem>();
		 List<SysCashAuthorityItem> updateSysCashAuthorityItemlist=new ArrayList<SysCashAuthorityItem>();
		 //SysCashuser
		 List<SysCashuser> insertSysCashuserlist=new ArrayList<SysCashuser>();
		 List<SysCashuser> deleteSysCashuserlist=new ArrayList<SysCashuser>();
		 List<SysCashuser> updateSysCashuserlist=new ArrayList<SysCashuser>();
		 //SysCheckuserInfo
		 List<SysCheckuserInfo> insertSysCheckuserInfolist=new ArrayList<SysCheckuserInfo>();
		 List<SysCheckuserInfo> deleteSysCheckuserInfolist=new ArrayList<SysCheckuserInfo>();
		 List<SysCheckuserInfo> updateSysCheckuserInfolist=new ArrayList<SysCheckuserInfo>();
		 //SysFieldNameDefs
		 List<SysFieldNameDefs> insertSysFieldNameDefslist=new ArrayList<SysFieldNameDefs>();
		 List<SysFieldNameDefs> deleteSysFieldNameDefslist=new ArrayList<SysFieldNameDefs>();
		 List<SysFieldNameDefs> updateSysFieldNameDefslist=new ArrayList<SysFieldNameDefs>();
		 //SysLogDtl
		 List<SysLogDtl> insertSysLogDtllist=new ArrayList<SysLogDtl>();
		 List<SysLogDtl> deleteSysLogDtllist=new ArrayList<SysLogDtl>();
		 List<SysLogDtl> updateSysLogDtllist=new ArrayList<SysLogDtl>();
		 //SysLogFields
		 List<SysLogFields> insertSysLogFieldslist=new ArrayList<SysLogFields>();
		 List<SysLogFields> deleteSysLogFieldslist=new ArrayList<SysLogFields>();
		 List<SysLogFields> updateSysLogFieldslist=new ArrayList<SysLogFields>();
		 //SysLoginCashLog
		 List<SysLoginCashLog> insertSysLoginCashLoglist=new ArrayList<SysLoginCashLog>();
		 List<SysLoginCashLog> deleteSysLoginCashLoglist=new ArrayList<SysLoginCashLog>();
		 List<SysLoginCashLog> updateSysLoginCashLoglist=new ArrayList<SysLoginCashLog>();
		 //SysLoginLog
		 List<SysLoginLog> insertSysLoginLoglist=new ArrayList<SysLoginLog>();
		 List<SysLoginLog> deleteSysLoginLoglist=new ArrayList<SysLoginLog>();
		 List<SysLoginLog> updateSysLoginLoglist=new ArrayList<SysLoginLog>();
		 //SysLog
		 List<SysLog> insertSysLoglist=new ArrayList<SysLog>();
		 List<SysLog> deleteSysLoglist=new ArrayList<SysLog>();
		 List<SysLog> updateSysLoglist=new ArrayList<SysLog>();
		 //SysModules
		 List<SysModules> insertSysModuleslist=new ArrayList<SysModules>();
		 List<SysModules> deleteSysModuleslist=new ArrayList<SysModules>();
		 List<SysModules> updateSysModuleslist=new ArrayList<SysModules>();
		//SysMyformActionCustomName
		 List<SysMyformActionCustomName> insertSysMyformActionCustomNamelist=new ArrayList<SysMyformActionCustomName>();
		 List<SysMyformActionCustomName> deleteSysMyformActionCustomNamelist=new ArrayList<SysMyformActionCustomName>();
		 List<SysMyformActionCustomName> updateSysMyformActionCustomNamelist=new ArrayList<SysMyformActionCustomName>();
		 //SysMymenu
		 List<SysMymenu> insertSysMymenulist=new ArrayList<SysMymenu>();
		 List<SysMymenu> deleteSysMymenulist=new ArrayList<SysMymenu>();
		 List<SysMymenu> updateSysMymenulist=new ArrayList<SysMymenu>();
		 //SysMyuserGroup
		 List<SysMyuserGroup> insertSysMyuserGrouplist=new ArrayList<SysMyuserGroup>();
		 List<SysMyuserGroup> deleteSysMyuserGrouplist=new ArrayList<SysMyuserGroup>();
		 List<SysMyuserGroup> updateSysMyuserGrouplist=new ArrayList<SysMyuserGroup>();
		 //SysMyuserGroupRe
		 List<SysMyuserGroupRe> insertSysMyuserGroupRelist=new ArrayList<SysMyuserGroupRe>();
		 List<SysMyuserGroupRe> deleteSysMyuserGroupRelist=new ArrayList<SysMyuserGroupRe>();
		 List<SysMyuserGroupRe> updateSysMyuserGroupRelist=new ArrayList<SysMyuserGroupRe>();
		//SysMyuser
		 List<SysMyuser> insertSysMyuserlist=new ArrayList<SysMyuser>();
		 List<SysMyuser> deleteSysMyuserlist=new ArrayList<SysMyuser>();
		 List<SysMyuser> updateSysMyuserlist=new ArrayList<SysMyuser>();
		 //SysMyuserRole
		 List<SysMyuserRole> insertSysMyuserRolelist=new ArrayList<SysMyuserRole>();
		 List<SysMyuserRole> deleteSysMyuserRolelist=new ArrayList<SysMyuserRole>();
		 List<SysMyuserRole> updateSysMyuserRolelist=new ArrayList<SysMyuserRole>(); 
		 //baseLadderPriceLog
		 List<baseLadderPriceLog> insertbaseLadderPriceLoglist=new ArrayList<baseLadderPriceLog>();
		 List<baseLadderPriceLog> deletebaseLadderPriceLoglist=new ArrayList<baseLadderPriceLog>();
		 List<baseLadderPriceLog> updatebaseLadderPriceLoglist=new ArrayList<baseLadderPriceLog>();
		 //baseLadderPrice
		 List<baseLadderPrice> insertbaseLadderPricelist=new ArrayList<baseLadderPrice>();
		 List<baseLadderPrice> deletebaseLadderPricelist=new ArrayList<baseLadderPrice>();
		 List<baseLadderPrice> updatebaseLadderPricelist=new ArrayList<baseLadderPrice>();
		 //baseMemberday
		 List<baseMemberday> insertbaseMemberdaylist=new ArrayList<baseMemberday>();
		 List<baseMemberday> deletebaseMemberdaylist=new ArrayList<baseMemberday>();
		 List<baseMemberday> updatebaseMemberdaylist=new ArrayList<baseMemberday>();
		 //BaseMonthlyBalance
		 List<BaseMonthlyBalance> insertBaseMonthlyBalancelist=new ArrayList<BaseMonthlyBalance>();
		 List<BaseMonthlyBalance> deleteBaseMonthlyBalancelist=new ArrayList<BaseMonthlyBalance>();
		 List<BaseMonthlyBalance> updateBaseMonthlyBalancelist=new ArrayList<BaseMonthlyBalance>();
		 //BaseMultiItem
		 List<BaseMultiItem> insertBaseMultiItemlist=new ArrayList<BaseMultiItem>();
		 List<BaseMultiItem> deleteBaseMultiItemlist=new ArrayList<BaseMultiItem>();
		 List<BaseMultiItem> updateBaseMultiItemlist=new ArrayList<BaseMultiItem>();
		 //BaseParmInfo
		 List<BaseParmInfo> insertBaseParmInfolist=new ArrayList<BaseParmInfo>();
		 List<BaseParmInfo> deleteBaseParmInfolist=new ArrayList<BaseParmInfo>();
		 List<BaseParmInfo> updateBaseParmInfolist=new ArrayList<BaseParmInfo>();
		 //OrderInstockGoods
		 List<OrderInstockGoods> insertOrderInstockGoodslist=new ArrayList<OrderInstockGoods>();
		 List<OrderInstockGoods> deleteOrderInstockGoodslist=new ArrayList<OrderInstockGoods>();
		 List<OrderInstockGoods> updateOrderInstockGoodslist=new ArrayList<OrderInstockGoods>();
		 //OrderInstockInfo
		 List<OrderInstockInfo> insertOrderInstockInfolist=new ArrayList<OrderInstockInfo>();
		 List<OrderInstockInfo> deleteOrderInstockInfolist=new ArrayList<OrderInstockInfo>();
		 List<OrderInstockInfo> updateOrderInstockInfolist=new ArrayList<OrderInstockInfo>();
		 //OrderPurchaseGoods
		 List<OrderPurchaseGoods> insertOrderPurchaseGoodslist=new ArrayList<OrderPurchaseGoods>();
		 List<OrderPurchaseGoods> deleteOrderPurchaseGoodslist=new ArrayList<OrderPurchaseGoods>();
		 List<OrderPurchaseGoods> updateOrderPurchaseGoodslist=new ArrayList<OrderPurchaseGoods>();
		 //OrderPurchaseInfo
		 List<OrderPurchaseInfo> insertOrderPurchaseInfolist=new ArrayList<OrderPurchaseInfo>();
		 List<OrderPurchaseInfo> deleteOrderPurchaseInfolist=new ArrayList<OrderPurchaseInfo>();
		 List<OrderPurchaseInfo> updateOrderPurchaseInfolist=new ArrayList<OrderPurchaseInfo>();
		 //BaseSupplierInfo
		 List<BaseSupplierInfo> insertBaseSupplierInfolist=new ArrayList<BaseSupplierInfo>();
		 List<BaseSupplierInfo> deleteBaseSupplierInfolist=new ArrayList<BaseSupplierInfo>();
		 List<BaseSupplierInfo> updateBaseSupplierInfolist=new ArrayList<BaseSupplierInfo>();
		 //BasePromotionInfoLog
		 List<BasePromotionInfoLog> insertBasePromotionInfoLoglist=new ArrayList<BasePromotionInfoLog>();
		 List<BasePromotionInfoLog> deleteBasePromotionInfoLoglist=new ArrayList<BasePromotionInfoLog>();
		 List<BasePromotionInfoLog> updateBasePromotionInfoLoglist=new ArrayList<BasePromotionInfoLog>();
		//BasePromotionInfo
		 List<BasePromotionInfo> insertBasePromotionInfolist=new ArrayList<BasePromotionInfo>();
		 List<BasePromotionInfo> deleteBasePromotionInfolist=new ArrayList<BasePromotionInfo>();
		 List<BasePromotionInfo> updateBasePromotionInfolist=new ArrayList<BasePromotionInfo>();
		 //BaseVouchersLog
		 List<BaseVouchersLog> insertBaseVouchersLoglist=new ArrayList<BaseVouchersLog>();
		 List<BaseVouchersLog> deleteBaseVouchersLoglist=new ArrayList<BaseVouchersLog>();
		 List<BaseVouchersLog> updateBaseVouchersLoglist=new ArrayList<BaseVouchersLog>();
		//BaseVouchers
		 List<BaseVouchers> insertBaseVoucherslist=new ArrayList<BaseVouchers>();
		 List<BaseVouchers> deleteBaseVoucherslist=new ArrayList<BaseVouchers>();
		 List<BaseVouchers> updateBaseVoucherslist=new ArrayList<BaseVouchers>();
		 //DailyGoodsInfo
		 List<DailyGoodsInfo> insertDailyGoodsInfolist=new ArrayList<DailyGoodsInfo>();
		 List<DailyGoodsInfo> deleteDailyGoodsInfolist=new ArrayList<DailyGoodsInfo>();
		 List<DailyGoodsInfo> updateDailyGoodsInfolist=new ArrayList<DailyGoodsInfo>();
		 //DailyGoodstypeInfo
		 List<DailyGoodstypeInfo> insertDailyGoodstypeInfolist=new ArrayList<DailyGoodstypeInfo>();
		 List<DailyGoodstypeInfo> deleteDailyGoodstypeInfolist=new ArrayList<DailyGoodstypeInfo>();
		 List<DailyGoodstypeInfo> updateDailyGoodstypeInfolist=new ArrayList<DailyGoodstypeInfo>();
		 //DailySaleamountInfo
		 List<DailySaleamountInfo> insertDailySaleamountInfolist=new ArrayList<DailySaleamountInfo>();
		 List<DailySaleamountInfo> deleteDailySaleamountInfolist=new ArrayList<DailySaleamountInfo>();
		 List<DailySaleamountInfo> updateDailySaleamountInfolist=new ArrayList<DailySaleamountInfo>();
		 //DailySuppliersaleInfo
		 List<DailySuppliersaleInfo> insertDailySuppliersaleInfolist=new ArrayList<DailySuppliersaleInfo>();
		 List<DailySuppliersaleInfo> deleteDailySuppliersaleInfolist=new ArrayList<DailySuppliersaleInfo>();
		 List<DailySuppliersaleInfo> updateDailySuppliersaleInfolist=new ArrayList<DailySuppliersaleInfo>();
		 //MonlyGoodsInfo
		 List<MonlyGoodsInfo> insertMonlyGoodsInfolist=new ArrayList<MonlyGoodsInfo>();
		 List<MonlyGoodsInfo> deleteMonlyGoodsInfolist=new ArrayList<MonlyGoodsInfo>();
		 List<MonlyGoodsInfo> updateMonlyGoodsInfolist=new ArrayList<MonlyGoodsInfo>();
		 //MonlyGoodsType
		 List<MonlyGoodsType> insertMonlyGoodsTypelist=new ArrayList<MonlyGoodsType>();
		 List<MonlyGoodsType> deleteMonlyGoodsTypelist=new ArrayList<MonlyGoodsType>();
		 List<MonlyGoodsType> updateMonlyGoodsTypelist=new ArrayList<MonlyGoodsType>();
		 //MonlySaleamountInfo
		 List<MonlySaleamountInfo> insertMonlySaleamountInfolist=new ArrayList<MonlySaleamountInfo>();
		 List<MonlySaleamountInfo> deleteMonlySaleamountInfolist=new ArrayList<MonlySaleamountInfo>();
		 List<MonlySaleamountInfo> updateMonlySaleamountInfolist=new ArrayList<MonlySaleamountInfo>();
		 //MonlySuppliersaleInfo
		 List<MonlySuppliersaleInfo> insertMonlySuppliersaleInfolist=new ArrayList<MonlySuppliersaleInfo>();
		 List<MonlySuppliersaleInfo> deleteMonlySuppliersaleInfolist=new ArrayList<MonlySuppliersaleInfo>();
		 List<MonlySuppliersaleInfo> updateMonlySuppliersaleInfolist=new ArrayList<MonlySuppliersaleInfo>();
		 //OrderInstockModifyLog
		 List<OrderInstockModifyLog> insertOrderInstockModifyLoglist=new ArrayList<OrderInstockModifyLog>();
		 List<OrderInstockModifyLog> deleteOrderInstockModifyLoglist=new ArrayList<OrderInstockModifyLog>();
		 List<OrderInstockModifyLog> updateOrderInstockModifyLoglist=new ArrayList<OrderInstockModifyLog>();
		 //xinXibiao
		 List<xinXibiao> insertxinXibiaolist=new ArrayList<xinXibiao>();
		 List<xinXibiao> deletexinXibiaolist=new ArrayList<xinXibiao>();
		 List<xinXibiao> updatexinXibiaolist=new ArrayList<xinXibiao>();
		 
		 //endregion
		
		 //FIXME
		 
		 //region  查询需要同步的数据

		 List<Tongbu> tlist= Service.selectAllNew(0);
		 int size=tlist.size();
		 
		 for(int i=0;i<size;i++)
		  {
		    String operate=tlist.get(i).getOperate();
			String Biaoming=tlist.get(i).getBiaoming();
			String idkey=tlist.get(i).getIdkey();
			if("".equals(idkey)||idkey==null)
			{
				int tongbuid=tlist.get(i).getId();
				  Service.updateState(tongbuid);
			}
			else
			{
				try{		
			if(".".equals(Biaoming))
			{
							
			}
			 else if("xinxibiao".equals(Biaoming))
				{
				
				 if("inserted".equals(operate))
					{ 
					  xinxi.setSmId(ming);					  
					  insertxinXibiaolist.add(xinxi);
					}
					else if("updated".equals(operate))
					{
						xinxi.setSmId(ming);	
					  updatexinXibiaolist.add(xinxi);
					}
				}
		 else if("order_goods_info".equals(Biaoming))
			{
			
			 if("inserted".equals(operate))
				{ 
				  sOrderGoodsInfo sinfo=new sOrderGoodsInfo();
				  sinfo.setOrderNum(idkey);
				  orderGoodsInfo info=sOrderGoodsInfoService.selectInfo(sinfo);
				  info.setSmId(ming);					  
				  insertorderGoodsInfolist.add(info);
				}
				else if("delete".equals(operate))
				{
				  orderGoodsInfo info=new orderGoodsInfo();
				  info.setOrderNum(idkey);
				  info.setSmId(ming);
				  deleteorderGoodsInfolist.add(info);
				}
				else if("updated".equals(operate))
				{
				  sOrderGoodsInfo sinfo=new sOrderGoodsInfo();
				  sinfo.setOrderNum(idkey);
				  orderGoodsInfo info=sOrderGoodsInfoService.selectInfo(sinfo);
				  info.setSmId(ming);
				  updateorderGoodsInfolist.add(info);
				}
			}
			else if("order_goods_list".equals(Biaoming))
			{
				if("inserted".equals(operate))
				{ 
				  sOrderGoodsList sList=new sOrderGoodsList();
				  int id=Integer.parseInt(idkey);
				  sList.setId(id);
				  OrderGoodsList List=sOrderGoodsListService.selectInfo(sList);
				  List.setSmId(ming);
				  insertOrderGoodsListlist.add(List);
				}
				else if("delete".equals(operate))
				{
				  OrderGoodsList List=new OrderGoodsList();
				  int id=Integer.parseInt(idkey);
				  List.setId(id);
				  List.setSmId(ming);
				  deleteOrderGoodsListlist.add(List);
				}
				else if("updated".equals(operate))
				{
				  sOrderGoodsList sList=new sOrderGoodsList();
				  int id=Integer.parseInt(idkey);
				  sList.setId(id);
				  OrderGoodsList List=sOrderGoodsListService.selectInfo(sList);
				  List.setSmId(ming);
				  updateOrderGoodsListlist.add(List);
				}				
			}
			 else if("base_charge_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseChargeInfo sinfo=new sBaseChargeInfo();
					  sinfo.setChargeNum(idkey);
					  BaseChargeInfo info=sBaseChargeInfoService.selectInfo(sinfo);
					  info.setSmId(ming);					  
					  insertBaseChargeInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseChargeInfo info=new BaseChargeInfo();
					  info.setChargeNum(idkey);
					  info.setSmId(ming);
					  deleteBaseChargeInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseChargeInfo sinfo=new sBaseChargeInfo();
					  sinfo.setChargeNum(idkey);
					  BaseChargeInfo info=sBaseChargeInfoService.selectInfo(sinfo);
					  info.setSmId(ming);
					  updateBaseChargeInfolist.add(info);
					}
				}
			 else if("base_customer_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseCustomerInfo sinfo=new sBaseCustomerInfo();
					  sinfo.setCustomerNum(idkey);
					  BaseCustomerInfo info=sBaseCustomerInfoService.selectInfo(sinfo);
					  info.setSmId(ming);					  
					  insertBaseCustomerInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseCustomerInfo info=new BaseCustomerInfo();
					  info.setCustomerNum(idkey);
					  info.setSmId(ming);
					  deleteBaseCustomerInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseCustomerInfo sinfo=new sBaseCustomerInfo();
					  sinfo.setCustomerNum(idkey);
					  BaseCustomerInfo info=sBaseCustomerInfoService.selectInfo(sinfo);
					  info.setSmId(ming);
					  updateBaseCustomerInfolist.add(info);
					}
				}
			 else if("base_goods_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseGoodsInfo sinfo=new sBaseGoodsInfo();
					  sinfo.setGoodsNum(idkey);
					  BaseGoodsInfo info=sBaseGoodsInfoService.selectInfo(sinfo);
					  info.setSmId(ming);					  
					  insertBaseGoodsInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseGoodsInfo info=new BaseGoodsInfo();
					  info.setGoodsNum(idkey);
					  info.setSmId(ming);
					  deleteBaseGoodsInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseGoodsInfo sinfo=new sBaseGoodsInfo();
					  sinfo.setGoodsNum(idkey);
					  BaseGoodsInfo info=sBaseGoodsInfoService.selectInfo(sinfo);
					  info.setSmId(ming);
					  updateBaseGoodsInfolist.add(info);
					}
				}
			 else if("base_goods_stock".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseGoodsStock sinfo=new sBaseGoodsStock();
					  sinfo.setGoodsNum(idkey);
					  BaseGoodsStock info=sBaseGoodsStockService.selectInfo(sinfo);
					  info.setSmId(ming);					  
					  insertBaseGoodsStocklist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseGoodsStock info=new BaseGoodsStock();
					  info.setGoodsNum(idkey);
					  info.setSmId(ming);
					  deleteBaseGoodsStocklist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseGoodsStock sinfo=new sBaseGoodsStock();
					  sinfo.setGoodsNum(idkey);
					  BaseGoodsStock info=sBaseGoodsStockService.selectInfo(sinfo);
					  info.setSmId(ming);
					  updateBaseGoodsStocklist.add(info);
					}
				}
			 else if("base_goods_unit".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseGoodsUnit sinfo=new sBaseGoodsUnit();
					  int id=Integer.parseInt(idkey);
					  sinfo.setId(id);
					  BaseGoodsUnit info=sBaseGoodsUnitService.selectInfo(sinfo);
					  info.setSmId(ming);					  
					  insertBaseGoodsUnitlist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseGoodsUnit info=new BaseGoodsUnit();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteBaseGoodsUnitlist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseGoodsUnit sinfo=new sBaseGoodsUnit();
					  int id=Integer.parseInt(idkey);
					  sinfo.setId(id);
					  BaseGoodsUnit info=sBaseGoodsUnitService.selectInfo(sinfo);
					  info.setSmId(ming);
					  updateBaseGoodsUnitlist.add(info);
					}
				}
			 else if("base_member_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseMemberInfo sInfo=new sBaseMemberInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setMid(id);
					  BaseMemberInfo info=sBaseMemberInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBaseMemberInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseMemberInfo info=new BaseMemberInfo();
					  int id=Integer.parseInt(idkey);
					   info.setMid(id);
					  info.setSmId(ming);
					  deleteBaseMemberInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseMemberInfo sInfo=new sBaseMemberInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setMid(id);
					  BaseMemberInfo info=sBaseMemberInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBaseMemberInfolist.add(info);
					}
				}
			 else if("base_member_log".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseMemberLog sInfo=new sBaseMemberLog();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseMemberLog info=sBaseMemberLogService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBaseMemberLoglist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseMemberLog info=new BaseMemberLog();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteBaseMemberLoglist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseMemberLog sInfo=new sBaseMemberLog();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseMemberLog info=sBaseMemberLogService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBaseMemberLoglist.add(info);
					}
				}
			 else if("base_scales_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseScalesInfo sInfo=new sBaseScalesInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseScalesInfo info=sBaseScalesInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBaseScalesInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseScalesInfo info=new BaseScalesInfo();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteBaseScalesInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseScalesInfo sInfo=new sBaseScalesInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseScalesInfo info=sBaseScalesInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBaseScalesInfolist.add(info);
					}
				}
			 else if("base_scales_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseScalesInfo sInfo=new sBaseScalesInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseScalesInfo info=sBaseScalesInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBaseScalesInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseScalesInfo info=new BaseScalesInfo();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteBaseScalesInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseScalesInfo sInfo=new sBaseScalesInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseScalesInfo info=sBaseScalesInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBaseScalesInfolist.add(info);
					}
				}
			 else if("base_shop_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseShopInfo sInfo=new sBaseShopInfo();
					  sInfo.setShopNum(idkey);
					  BaseShopInfo info=sBaseShopInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBaseShopInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseShopInfo info=new BaseShopInfo();
					  info.setShopNum(idkey);
					  info.setSmId(ming);
					  deleteBaseShopInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseShopInfo sInfo=new sBaseShopInfo();
					  sInfo.setShopNum(idkey);
					  BaseShopInfo info=sBaseShopInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBaseShopInfolist.add(info);
					}
				}
			 else if("base_special_price_log".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseSpecialPriceLog sInfo=new sBaseSpecialPriceLog();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseSpecialPriceLog info=sBaseSpecialPriceLogService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBaseSpecialPriceLoglist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseSpecialPriceLog info=new BaseSpecialPriceLog();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteBaseSpecialPriceLoglist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseSpecialPriceLog sInfo=new sBaseSpecialPriceLog();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseSpecialPriceLog info=sBaseSpecialPriceLogService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBaseSpecialPriceLoglist.add(info);
					}
				}
			 else if("base_special_price".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseSpecialPrice sInfo=new sBaseSpecialPrice();
					  sInfo.setGoodsNum(idkey);
					  BaseSpecialPrice info=sBaseSpecialPriceService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBaseSpecialPricelist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseSpecialPrice info=new BaseSpecialPrice();
					  info.setGoodsNum(idkey);
					  info.setSmId(ming);
					  deleteBaseSpecialPricelist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseSpecialPrice sInfo=new sBaseSpecialPrice();
					  sInfo.setGoodsNum(idkey);
					  BaseSpecialPrice info=sBaseSpecialPriceService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBaseSpecialPricelist.add(info);
					}
				}
			 else if("base_special_themegoods".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseSpecialThemegoods sInfo=new sBaseSpecialThemegoods();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseSpecialThemegoods info=sBaseSpecialThemegoodsService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBaseSpecialThemegoodslist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseSpecialThemegoods info=new BaseSpecialThemegoods();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteBaseSpecialThemegoodslist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseSpecialThemegoods sInfo=new sBaseSpecialThemegoods();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseSpecialThemegoods info=sBaseSpecialThemegoodsService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBaseSpecialThemegoodslist.add(info);
					}
				}
			 else if("base_special_theme".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseSpecialTheme sInfo=new sBaseSpecialTheme();
					  sInfo.setThemeNum(idkey);
					  BaseSpecialTheme info=sBaseSpecialThemeService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBaseSpecialThemelist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseSpecialTheme info=new BaseSpecialTheme();
					  info.setThemeNum(idkey);
					  info.setSmId(ming);
					  deleteBaseSpecialThemelist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseSpecialTheme sInfo=new sBaseSpecialTheme();
					  sInfo.setThemeNum(idkey);
					  BaseSpecialTheme info=sBaseSpecialThemeService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBaseSpecialThemelist.add(info);
					}
				}
			 else if("base_supplier_paytype".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseSupplierPaytype sInfo=new sBaseSupplierPaytype();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseSupplierPaytype info=sBaseSupplierPaytypeService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBaseSupplierPaytypelist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseSupplierPaytype info=new BaseSupplierPaytype();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteBaseSupplierPaytypelist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseSupplierPaytype sInfo=new sBaseSupplierPaytype();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseSupplierPaytype info=sBaseSupplierPaytypeService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBaseSupplierPaytypelist.add(info);
					}
				}
			 else if("base_type_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseTypeInfo sInfo=new sBaseTypeInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseTypeInfo info=sBaseTypeInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBaseTypeInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseTypeInfo info=new BaseTypeInfo();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteBaseTypeInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseTypeInfo sInfo=new sBaseTypeInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseTypeInfo info=sBaseTypeInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBaseTypeInfolist.add(info);
					}
				}
			 else if("base_valuecard_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseValuecardInfo sInfo=new sBaseValuecardInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseValuecardInfo info=sBaseValuecardInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBaseValuecardInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseValuecardInfo info=new BaseValuecardInfo();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteBaseValuecardInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseValuecardInfo sInfo=new sBaseValuecardInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseValuecardInfo info=sBaseValuecardInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBaseValuecardInfolist.add(info);
					}
				}
			 else if("base_valuecard_log".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseValuecardLog sInfo=new sBaseValuecardLog();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseValuecardLog info=sBaseValuecardLogService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBaseValuecardLoglist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseValuecardLog info=new BaseValuecardLog();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteBaseValuecardLoglist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseValuecardLog sInfo=new sBaseValuecardLog();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseValuecardLog info=sBaseValuecardLogService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBaseValuecardLoglist.add(info);
					}
				}
			 else if("base_village".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseVillage sInfo=new sBaseVillage();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseVillage info=sBaseVillageService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBaseVillagelist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseVillage info=new BaseVillage();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteBaseVillagelist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseVillage sInfo=new sBaseVillage();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseVillage info=sBaseVillageService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBaseVillagelist.add(info);
					}
				}
			 else if("base_warehouse_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseWarehouseInfo sInfo=new sBaseWarehouseInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseWarehouseInfo info=sBaseWarehouseInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBaseWarehouseInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseWarehouseInfo info=new BaseWarehouseInfo();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteBaseWarehouseInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseWarehouseInfo sInfo=new sBaseWarehouseInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseWarehouseInfo info=sBaseWarehouseInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBaseWarehouseInfolist.add(info);
					}
				}
			 else if("base_web_village".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseWebVillage sInfo=new sBaseWebVillage();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseWebVillage info=sBaseWebVillageService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBaseWebVillagelist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseWebVillage info=new BaseWebVillage();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteBaseWebVillagelist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseWebVillage sInfo=new sBaseWebVillage();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseWebVillage info=sBaseWebVillageService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBaseWebVillagelist.add(info);
					}
				}
			 else if("order_allot_goods".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderAllotGoods sInfo=new sOrderAllotGoods();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderAllotGoods info=sOrderAllotGoodsService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderAllotGoodslist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderAllotGoods info=new OrderAllotGoods();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteOrderAllotGoodslist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderAllotGoods sInfo=new sOrderAllotGoods();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderAllotGoods info=sOrderAllotGoodsService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderAllotGoodslist.add(info);
					}
				}
			 else if("order_allot_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderAllotInfo sInfo=new sOrderAllotInfo();
					  sInfo.setOrderNum(idkey);
					  OrderAllotInfo info=sOrderAllotInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderAllotInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderAllotInfo info=new OrderAllotInfo();
					  info.setOrderNum(idkey);
					  info.setSmId(ming);
					  deleteOrderAllotInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderAllotInfo sInfo=new sOrderAllotInfo();
					  sInfo.setOrderNum(idkey);
					  OrderAllotInfo info=sOrderAllotInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderAllotInfolist.add(info);
					}
				}
			 else if("order_bigsale_goods".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderBigsaleGoods sInfo=new sOrderBigsaleGoods();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderBigsaleGoods info=sOrderBigsaleGoodsService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderBigsaleGoodslist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderBigsaleGoods info=new OrderBigsaleGoods();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteOrderBigsaleGoodslist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderBigsaleGoods sInfo=new sOrderBigsaleGoods();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderBigsaleGoods info=sOrderBigsaleGoodsService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderBigsaleGoodslist.add(info);
					}
				}
			 else if("order_bigsale_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderBigsaleInfo sInfo=new sOrderBigsaleInfo();
					  sInfo.setOrderNum(idkey);
					  OrderBigsaleInfo info=sOrderBigsaleInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderBigsaleInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderBigsaleInfo info=new OrderBigsaleInfo();
					  info.setOrderNum(idkey);
					  info.setSmId(ming);
					  deleteOrderBigsaleInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderBigsaleInfo sInfo=new sOrderBigsaleInfo();
					  sInfo.setOrderNum(idkey);
					  OrderBigsaleInfo info=sOrderBigsaleInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderBigsaleInfolist.add(info);
					}
				}
			 else if("order_breakage_goods".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderBreakageGoods sInfo=new sOrderBreakageGoods();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderBreakageGoods info=sOrderBreakageGoodsService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderBreakageGoodslist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderBreakageGoods info=new OrderBreakageGoods();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteOrderBreakageGoodslist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderBreakageGoods sInfo=new sOrderBreakageGoods();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderBreakageGoods info=sOrderBreakageGoodsService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderBreakageGoodslist.add(info);
					}
				}
			 else if("order_breakage_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderBreakageInfo sInfo=new sOrderBreakageInfo();
					  sInfo.setOrderNum(idkey);
					  OrderBreakageInfo info=sOrderBreakageInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderBreakageInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderBreakageInfo info=new OrderBreakageInfo();
					  info.setOrderNum(idkey);
					  info.setSmId(ming);
					  deleteOrderBreakageInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderBreakageInfo sInfo=new sOrderBreakageInfo();
					  sInfo.setOrderNum(idkey);
					  OrderBreakageInfo info=sOrderBreakageInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderBreakageInfolist.add(info);
					}
				}
			 else if("order_collection_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderCollectionInfo sInfo=new sOrderCollectionInfo();
					  sInfo.setOrderNum(idkey);
					  OrderCollectionInfo info=sOrderCollectionInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderCollectionInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderCollectionInfo info=new OrderCollectionInfo();
					  info.setOrderNum(idkey);
					  info.setSmId(ming);
					  deleteOrderCollectionInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderCollectionInfo sInfo=new sOrderCollectionInfo();
					  sInfo.setOrderNum(idkey);
					  OrderCollectionInfo info=sOrderCollectionInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderCollectionInfolist.add(info);
					}
				}
			 else if("order_collection_list".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderCollectionList sInfo=new sOrderCollectionList();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderCollectionList info=sOrderCollectionListService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderCollectionListlist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderCollectionList info=new OrderCollectionList();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteOrderCollectionListlist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderCollectionList sInfo=new sOrderCollectionList();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderCollectionList info=sOrderCollectionListService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderCollectionListlist.add(info);
					}
				}
			 else if("order_deductmoney_goods".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderDeductmoneyGoods sInfo=new sOrderDeductmoneyGoods();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderDeductmoneyGoods info=sOrderDeductmoneyGoodsService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderDeductmoneyGoodslist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderDeductmoneyGoods info=new OrderDeductmoneyGoods();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteOrderDeductmoneyGoodslist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderDeductmoneyGoods sInfo=new sOrderDeductmoneyGoods();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderDeductmoneyGoods info=sOrderDeductmoneyGoodsService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderDeductmoneyGoodslist.add(info);
					}
				}
			 else if("order_deductmoney_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderDeductmoneyInfo sInfo=new sOrderDeductmoneyInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderDeductmoneyInfo info=sOrderDeductmoneyInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderDeductmoneyInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderDeductmoneyInfo info=new OrderDeductmoneyInfo();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteOrderDeductmoneyInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderDeductmoneyInfo sInfo=new sOrderDeductmoneyInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderDeductmoneyInfo info=sOrderDeductmoneyInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderDeductmoneyInfolist.add(info);
					}
				}
			 else if("order_delay_goodslist".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderDelayGoodslist sInfo=new sOrderDelayGoodslist();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderDelayGoodslist info=sOrderDelayGoodslistService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderDelayGoodslistlist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderDelayGoodslist info=new OrderDelayGoodslist();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteOrderDelayGoodslistlist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderDelayGoodslist sInfo=new sOrderDelayGoodslist();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderDelayGoodslist info=sOrderDelayGoodslistService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderDelayGoodslistlist.add(info);
					}
				}
			 else if("order_delay_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderDelayInfo sInfo=new sOrderDelayInfo();
					  sInfo.setOrderNum(idkey);
					  OrderDelayInfo info=sOrderDelayInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderDelayInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderDelayInfo info=new OrderDelayInfo();
					  info.setOrderNum(idkey);
					  info.setSmId(ming);
					  deleteOrderDelayInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderDelayInfo sInfo=new sOrderDelayInfo();
					  sInfo.setOrderNum(idkey);
					  OrderDelayInfo info=sOrderDelayInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderDelayInfolist.add(info);
					}
				}
			 else if("order_freegoods_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderFreegoodsInfo sInfo=new sOrderFreegoodsInfo();
					  sInfo.setOrderNum(idkey);
					  OrderFreegoodsInfo info=sOrderFreegoodsInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderFreegoodsInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderFreegoodsInfo info=new OrderFreegoodsInfo();
					  info.setOrderNum(idkey);
					  info.setSmId(ming);
					  deleteOrderFreegoodsInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderFreegoodsInfo sInfo=new sOrderFreegoodsInfo();
					  sInfo.setOrderNum(idkey);
					  OrderFreegoodsInfo info=sOrderFreegoodsInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderFreegoodsInfolist.add(info);
					}
				}
			 else if("order_freegoods_list".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderFreegoodsList sInfo=new sOrderFreegoodsList();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderFreegoodsList info=sOrderFreegoodsListService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderFreegoodsListlist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderFreegoodsList info=new OrderFreegoodsList();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteOrderFreegoodsListlist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderFreegoodsList sInfo=new sOrderFreegoodsList();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderFreegoodsList info=sOrderFreegoodsListService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderFreegoodsListlist.add(info);
					}
				}
			 else if("order_handin_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderHandinInfo sInfo=new sOrderHandinInfo();
					  sInfo.setOrderNum(idkey);
					  OrderHandinInfo info=sOrderHandinInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderHandinInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderHandinInfo info=new OrderHandinInfo();
					  info.setOrderNum(idkey);
					  info.setSmId(ming);
					  deleteOrderHandinInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderHandinInfo sInfo=new sOrderHandinInfo();
					  sInfo.setOrderNum(idkey);
					  OrderHandinInfo info=sOrderHandinInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderHandinInfolist.add(info);
					}
				}
			 else if("order_handin_list".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderHandinList sInfo=new sOrderHandinList();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderHandinList info=sOrderHandinListService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderHandinListlist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderHandinList info=new OrderHandinList();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteOrderHandinListlist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderHandinList sInfo=new sOrderHandinList();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderHandinList info=sOrderHandinListService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderHandinListlist.add(info);
					}
				}
			 else if("order_interioruse_goods".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderInterioruseGoods sInfo=new sOrderInterioruseGoods();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderInterioruseGoods info=sOrderInterioruseGoodsService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderInterioruseGoodslist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderInterioruseGoods info=new OrderInterioruseGoods();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteOrderInterioruseGoodslist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderInterioruseGoods sInfo=new sOrderInterioruseGoods();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderInterioruseGoods info=sOrderInterioruseGoodsService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderInterioruseGoodslist.add(info);
					}
				}
			 else if("order_interioruse_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderInterioruseInfo sInfo=new sOrderInterioruseInfo();
					  sInfo.setOrderNum(idkey);
					  OrderInterioruseInfo info=sOrderInterioruseInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderInterioruseInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderInterioruseInfo info=new OrderInterioruseInfo();
					  info.setOrderNum(idkey);
					  info.setSmId(ming);
					  deleteOrderInterioruseInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderInterioruseInfo sInfo=new sOrderInterioruseInfo();
					  sInfo.setOrderNum(idkey);
					  OrderInterioruseInfo info=sOrderInterioruseInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderInterioruseInfolist.add(info);
					}
				}
			 else if("order_inventory_goods".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderInventoryGoods sInfo=new sOrderInventoryGoods();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderInventoryGoods info=sOrderInventoryGoodsService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderInventoryGoodslist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderInventoryGoods info=new OrderInventoryGoods();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteOrderInventoryGoodslist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderInventoryGoods sInfo=new sOrderInventoryGoods();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderInventoryGoods info=sOrderInventoryGoodsService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderInventoryGoodslist.add(info);
					}
				}
			 else if("order_inventory_group".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderInventoryGroup sInfo=new sOrderInventoryGroup();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderInventoryGroup info=sOrderInventoryGroupService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderInventoryGrouplist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderInventoryGroup info=new OrderInventoryGroup();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteOrderInventoryGrouplist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderInventoryGroup sInfo=new sOrderInventoryGroup();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderInventoryGroup info=sOrderInventoryGroupService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderInventoryGrouplist.add(info);
					}
				}
			 else if("order_inventory_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderInventoryInfo sInfo=new sOrderInventoryInfo();
					  sInfo.setOrderNum(idkey);
					  OrderInventoryInfo info=sOrderInventoryInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderInventoryInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderInventoryInfo info=new OrderInventoryInfo();
					  info.setOrderNum(idkey);
					  info.setSmId(ming);
					  deleteOrderInventoryInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderInventoryInfo sInfo=new sOrderInventoryInfo();
					  sInfo.setOrderNum(idkey);
					  OrderInventoryInfo info=sOrderInventoryInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderInventoryInfolist.add(info);
					}
				}
			 else if("order_inventory_person".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderInventoryPerson sInfo=new sOrderInventoryPerson();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderInventoryPerson info=sOrderInventoryPersonService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderInventoryPersonlist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderInventoryPerson info=new OrderInventoryPerson();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteOrderInventoryPersonlist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderInventoryPerson sInfo=new sOrderInventoryPerson();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderInventoryPerson info=sOrderInventoryPersonService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderInventoryPersonlist.add(info);
					}
				}
			 else if("order_outstock_goods".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderOutstockGoods sInfo=new sOrderOutstockGoods();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderOutstockGoods info=sOrderOutstockGoodsService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderOutstockGoodslist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderOutstockGoods info=new OrderOutstockGoods();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteOrderOutstockGoodslist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderOutstockGoods sInfo=new sOrderOutstockGoods();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderOutstockGoods info=sOrderOutstockGoodsService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderOutstockGoodslist.add(info);
					}
				}
			 else if("order_outstock_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderOutstockInfo sInfo=new sOrderOutstockInfo();
					  sInfo.setOrderNum(idkey);
					  OrderOutstockInfo info=sOrderOutstockInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderOutstockInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderOutstockInfo info=new OrderOutstockInfo();
					  info.setOrderNum(idkey);
					  info.setSmId(ming);
					  deleteOrderOutstockInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderOutstockInfo sInfo=new sOrderOutstockInfo();
					  sInfo.setOrderNum(idkey);
					  OrderOutstockInfo info=sOrderOutstockInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderOutstockInfolist.add(info);
					}
				}
			 else if("order_payment_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderPaymentInfo sInfo=new sOrderPaymentInfo();
					  sInfo.setOrderNum(idkey);
					  OrderPaymentInfo info=sOrderPaymentInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderPaymentInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderPaymentInfo info=new OrderPaymentInfo();
					  info.setOrderNum(idkey);
					  info.setSmId(ming);
					  deleteOrderPaymentInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderPaymentInfo sInfo=new sOrderPaymentInfo();
					  sInfo.setOrderNum(idkey);
					  OrderPaymentInfo info=sOrderPaymentInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderPaymentInfolist.add(info);
					}
				}
			 else if("order_payment_list".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderPaymentList sInfo=new sOrderPaymentList();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderPaymentList info=sOrderPaymentListService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderPaymentListlist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderPaymentList info=new OrderPaymentList();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteOrderPaymentListlist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderPaymentList sInfo=new sOrderPaymentList();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderPaymentList info=sOrderPaymentListService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderPaymentListlist.add(info);
					}
				}
			 else if("order_pool_payment_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderPoolPaymentInfo sInfo=new sOrderPoolPaymentInfo();
					  sInfo.setOrderNum(idkey);
					  OrderPoolPaymentInfo info=sOrderPoolPaymentInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderPoolPaymentInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderPoolPaymentInfo info=new OrderPoolPaymentInfo();
					  info.setOrderNum(idkey);
					  info.setSmId(ming);
					  deleteOrderPoolPaymentInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderPoolPaymentInfo sInfo=new sOrderPoolPaymentInfo();
					  sInfo.setOrderNum(idkey);
					  OrderPoolPaymentInfo info=sOrderPoolPaymentInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderPoolPaymentInfolist.add(info);
					}
				}
			 else if("order_pool_payment_list".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderPoolPaymentList sInfo=new sOrderPoolPaymentList();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderPoolPaymentList info=sOrderPoolPaymentListService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderPoolPaymentListlist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderPoolPaymentList info=new OrderPoolPaymentList();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteOrderPoolPaymentListlist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderPoolPaymentList sInfo=new sOrderPoolPaymentList();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderPoolPaymentList info=sOrderPoolPaymentListService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderPoolPaymentListlist.add(info);
					}
				}
			 else if("order_pool_settlement_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderPoolSettlementInfo sInfo=new sOrderPoolSettlementInfo();
					  sInfo.setOrderNum(idkey);
					  OrderPoolSettlementInfo info=sOrderPoolSettlementInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderPoolSettlementInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderPoolSettlementInfo info=new OrderPoolSettlementInfo();
					  info.setOrderNum(idkey);
					  info.setSmId(ming);
					  deleteOrderPoolSettlementInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderPoolSettlementInfo sInfo=new sOrderPoolSettlementInfo();
					  sInfo.setOrderNum(idkey);
					  OrderPoolSettlementInfo info=sOrderPoolSettlementInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderPoolSettlementInfolist.add(info);
					}
				}
			 else if("order_procurement_goods".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderProcurementGoods sInfo=new sOrderProcurementGoods();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderProcurementGoods info=sOrderProcurementGoodsService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderProcurementGoodslist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderProcurementGoods info=new OrderProcurementGoods();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteOrderProcurementGoodslist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderProcurementGoods sInfo=new sOrderProcurementGoods();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderProcurementGoods info=sOrderProcurementGoodsService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderProcurementGoodslist.add(info);
					}
				}
			 else if("order_procurement_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderProcurementInfo sInfo=new sOrderProcurementInfo();
					  sInfo.setOrderNum(idkey);
					  OrderProcurementInfo info=sOrderProcurementInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderProcurementInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderProcurementInfo info=new OrderProcurementInfo();
					  info.setOrderNum(idkey);
					  info.setSmId(ming);
					  deleteOrderProcurementInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderProcurementInfo sInfo=new sOrderProcurementInfo();
					  sInfo.setOrderNum(idkey);
					  OrderProcurementInfo info=sOrderProcurementInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderProcurementInfolist.add(info);
					}
				}
			 else if("order_return_goodslist".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderReturnGoodslist sInfo=new sOrderReturnGoodslist();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderReturnGoodslist info=sOrderReturnGoodslistService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderReturnGoodslistlist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderReturnGoodslist info=new OrderReturnGoodslist();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteOrderReturnGoodslistlist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderReturnGoodslist sInfo=new sOrderReturnGoodslist();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderReturnGoodslist info=sOrderReturnGoodslistService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderReturnGoodslistlist.add(info);
					}
				}
			 else if("order_return_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderReturnInfo sInfo=new sOrderReturnInfo();
					  sInfo.setOrderNum(idkey);
					  OrderReturnInfo info=sOrderReturnInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderReturnInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderReturnInfo info=new OrderReturnInfo();
					  info.setOrderNum(idkey);
					  info.setSmId(ming);
					  deleteOrderReturnInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderReturnInfo sInfo=new sOrderReturnInfo();
					  sInfo.setOrderNum(idkey);
					  OrderReturnInfo info=sOrderReturnInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderReturnInfolist.add(info);
					}
				}
			 else if("order_scharge_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderSchargeInfo sInfo=new sOrderSchargeInfo();
					  sInfo.setOrderNum(idkey);
					  OrderSchargeInfo info=sOrderSchargeInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderSchargeInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderSchargeInfo info=new OrderSchargeInfo();
					  info.setOrderNum(idkey);
					  info.setSmId(ming);
					  deleteOrderSchargeInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderSchargeInfo sInfo=new sOrderSchargeInfo();
					  sInfo.setOrderNum(idkey);
					  OrderSchargeInfo info=sOrderSchargeInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderSchargeInfolist.add(info);
					}
				}
			 else if("order_scharge_list".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderSchargeList sInfo=new sOrderSchargeList();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderSchargeList info=sOrderSchargeListService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderSchargeListlist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderSchargeList info=new OrderSchargeList();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteOrderSchargeListlist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderSchargeList sInfo=new sOrderSchargeList();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderSchargeList info=sOrderSchargeListService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderSchargeListlist.add(info);
					}
				}
			 else if("order_spayment_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderSpaymentInfo sInfo=new sOrderSpaymentInfo();
					  sInfo.setOrderNum(idkey);
					  OrderSpaymentInfo info=sOrderSpaymentInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderSpaymentInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderSpaymentInfo info=new OrderSpaymentInfo();
					  info.setOrderNum(idkey);
					  info.setSmId(ming);
					  deleteOrderSpaymentInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderSpaymentInfo sInfo=new sOrderSpaymentInfo();
					  sInfo.setOrderNum(idkey);
					  OrderSpaymentInfo info=sOrderSpaymentInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderSpaymentInfolist.add(info);
					}
				}
			 else if("order_spayment_list".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderSpaymentList sInfo=new sOrderSpaymentList();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderSpaymentList info=sOrderSpaymentListService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderSpaymentListlist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderSpaymentList info=new OrderSpaymentList();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteOrderSpaymentListlist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderSpaymentList sInfo=new sOrderSpaymentList();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderSpaymentList info=sOrderSpaymentListService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderSpaymentListlist.add(info);
					}
				}
			 else if("sys_authority_item".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sSysAuthorityItem sInfo=new sSysAuthorityItem();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysAuthorityItem info=sSysAuthorityItemService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertSysAuthorityItemlist.add(info);
					}
					else if("delete".equals(operate))
					{
					  SysAuthorityItem info=new SysAuthorityItem();
					  int id=Integer.parseInt(idkey);
					  info.setIsid(id);
					  info.setSmId(ming);
					  deleteSysAuthorityItemlist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sSysAuthorityItem sInfo=new sSysAuthorityItem();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysAuthorityItem info=sSysAuthorityItemService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateSysAuthorityItemlist.add(info);
					}
				}
			 else if("sys_backuphistory".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sSysBackupHistory sInfo=new sSysBackupHistory();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  SysBackupHistory info=sSysBackupHistoryService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertSysBackupHistorylist.add(info);
					}
					else if("delete".equals(operate))
					{
					  SysBackupHistory info=new SysBackupHistory();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteSysBackupHistorylist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sSysBackupHistory sInfo=new sSysBackupHistory();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  SysBackupHistory info=sSysBackupHistoryService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateSysBackupHistorylist.add(info);
					}
				}
			 else if("sys_businesstables".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sSysBusinessTables sInfo=new sSysBusinessTables();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysBusinessTables info=sSysBusinessTablesService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertSysBusinessTableslist.add(info);
					}
					else if("delete".equals(operate))
					{
					  SysBusinessTables info=new SysBusinessTables();
					  int id=Integer.parseInt(idkey);
					  info.setIsid(id);
					  info.setSmId(ming);
					  deleteSysBusinessTableslist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sSysBusinessTables sInfo=new sSysBusinessTables();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysBusinessTables info=sSysBusinessTablesService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateSysBusinessTableslist.add(info);
					}
				}
			 else if("sys_cash_authority_item".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sSysCashAuthorityItem sInfo=new sSysCashAuthorityItem();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysCashAuthorityItem info=sSysCashAuthorityItemService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertSysCashAuthorityItemlist.add(info);
					}
					else if("delete".equals(operate))
					{
					  SysCashAuthorityItem info=new SysCashAuthorityItem();
					  int id=Integer.parseInt(idkey);
					  info.setIsid(id);
					  info.setSmId(ming);
					  deleteSysCashAuthorityItemlist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sSysCashAuthorityItem sInfo=new sSysCashAuthorityItem();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysCashAuthorityItem info=sSysCashAuthorityItemService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateSysCashAuthorityItemlist.add(info);
					}
				}
			 else if("sys_cashuser".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sSysCashuser sInfo=new sSysCashuser();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysCashuser info=sSysCashuserService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertSysCashuserlist.add(info);
					}
					else if("delete".equals(operate))
					{
					  SysCashuser info=new SysCashuser();
					  int id=Integer.parseInt(idkey);
					  info.setIsid(id);
					  info.setSmId(ming);
					  deleteSysCashuserlist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sSysCashuser sInfo=new sSysCashuser();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysCashuser info=sSysCashuserService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateSysCashuserlist.add(info);
					}
				}
			 else if("sys_checkuser_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sSysCheckuserInfo sInfo=new sSysCheckuserInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  SysCheckuserInfo info=sSysCheckuserInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertSysCheckuserInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  SysCheckuserInfo info=new SysCheckuserInfo();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteSysCheckuserInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sSysCheckuserInfo sInfo=new sSysCheckuserInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  SysCheckuserInfo info=sSysCheckuserInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateSysCheckuserInfolist.add(info);
					}
				}
			 else if("sys_FieldNameDefs".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sSysFieldNameDefs sInfo=new sSysFieldNameDefs();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysFieldNameDefs info=sSysFieldNameDefsService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertSysFieldNameDefslist.add(info);
					}
					else if("delete".equals(operate))
					{
					  SysFieldNameDefs info=new SysFieldNameDefs();
					  int id=Integer.parseInt(idkey);
					  info.setIsid(id);
					  info.setSmId(ming);
					  deleteSysFieldNameDefslist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sSysFieldNameDefs sInfo=new sSysFieldNameDefs();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysFieldNameDefs info=sSysFieldNameDefsService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateSysFieldNameDefslist.add(info);
					}
				}
			 else if("sys_LogDtl".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sSysLogDtl sInfo=new sSysLogDtl();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysLogDtl info=sSysLogDtlService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertSysLogDtllist.add(info);
					}
					else if("delete".equals(operate))
					{
					  SysLogDtl info=new SysLogDtl();
					  int id=Integer.parseInt(idkey);
					  info.setIsid(id);
					  info.setSmId(ming);
					  deleteSysLogDtllist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sSysLogDtl sInfo=new sSysLogDtl();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysLogDtl info=sSysLogDtlService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateSysLogDtllist.add(info);
					}
				}
			 else if("sys_LogFields".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sSysLogFields sInfo=new sSysLogFields();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysLogFields info=sSysLogFieldsService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertSysLogFieldslist.add(info);
					}
					else if("delete".equals(operate))
					{
					  SysLogFields info=new SysLogFields();
					  int id=Integer.parseInt(idkey);
					  info.setIsid(id);
					  info.setSmId(ming);
					  deleteSysLogFieldslist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sSysLogFields sInfo=new sSysLogFields();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysLogFields info=sSysLogFieldsService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateSysLogFieldslist.add(info);
					}
				}
			 else if("sys_login_cash_log".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sSysLoginCashLog sInfo=new sSysLoginCashLog();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysLoginCashLog info=sSysLoginCashLogService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertSysLoginCashLoglist.add(info);
					}
					else if("delete".equals(operate))
					{
					  SysLoginCashLog info=new SysLoginCashLog();
					  int id=Integer.parseInt(idkey);
					  info.setIsid(id);
					  info.setSmId(ming);
					  deleteSysLoginCashLoglist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sSysLoginCashLog sInfo=new sSysLoginCashLog();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysLoginCashLog info=sSysLoginCashLogService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateSysLoginCashLoglist.add(info);
					}
				}
			 else if("sys_login_log".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sSysLoginLog sInfo=new sSysLoginLog();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysLoginLog info=sSysLoginLogService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertSysLoginLoglist.add(info);
					}
					else if("delete".equals(operate))
					{
					  SysLoginLog info=new SysLoginLog();
					  int id=Integer.parseInt(idkey);
					  info.setIsid(id);
					  info.setSmId(ming);
					  deleteSysLoginLoglist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sSysLoginLog sInfo=new sSysLoginLog();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysLoginLog info=sSysLoginLogService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateSysLoginLoglist.add(info);
					}
				}
			 else if("sys_Log".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sSysLog sInfo=new sSysLog();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysLog info=sSysLogService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertSysLoglist.add(info);
					}
					else if("delete".equals(operate))
					{
					  SysLog info=new SysLog();
					  int id=Integer.parseInt(idkey);
					  info.setIsid(id);
					  info.setSmId(ming);
					  deleteSysLoglist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sSysLog sInfo=new sSysLog();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysLog info=sSysLogService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateSysLoglist.add(info);
					}
				}
			 else if("sys_Modules".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sSysModules sInfo=new sSysModules();
					  int id=Integer.parseInt(idkey);
					  sInfo.setModuleid(id);
					  SysModules info=sSysModulesService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertSysModuleslist.add(info);
					}
					else if("delete".equals(operate))
					{
					  SysModules info=new SysModules();
					  int id=Integer.parseInt(idkey);
					  info.setModuleid(id);
					  info.setSmId(ming);
					  deleteSysModuleslist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sSysModules sInfo=new sSysModules();
					  int id=Integer.parseInt(idkey);
					  sInfo.setModuleid(id);
					  SysModules info=sSysModulesService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateSysModuleslist.add(info);
					}
				}
			 else if("sys_myform_action_customname".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sSysMyformActionCustomName sInfo=new sSysMyformActionCustomName();
					  int id=Integer.parseInt(idkey);
					  sInfo.setAuid(id);
					  SysMyformActionCustomName info=sSysMyformActionCustomNameService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertSysMyformActionCustomNamelist.add(info);
					}
					else if("delete".equals(operate))
					{
					  SysMyformActionCustomName info=new SysMyformActionCustomName();
					  int id=Integer.parseInt(idkey);
					  info.setAuid(id);
					  info.setSmId(ming);
					  deleteSysMyformActionCustomNamelist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sSysMyformActionCustomName sInfo=new sSysMyformActionCustomName();
					  int id=Integer.parseInt(idkey);
					  sInfo.setAuid(id);
					  SysMyformActionCustomName info=sSysMyformActionCustomNameService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateSysMyformActionCustomNamelist.add(info);
					}
				}
			 else if("sys_mymenu".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sSysMymenu sInfo=new sSysMymenu();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysMymenu info=sSysMymenuService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertSysMymenulist.add(info);
					}
					else if("delete".equals(operate))
					{
					  SysMymenu info=new SysMymenu();
					  int id=Integer.parseInt(idkey);
					  info.setIsid(id);
					  info.setSmId(ming);
					  deleteSysMymenulist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sSysMymenu sInfo=new sSysMymenu();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysMymenu info=sSysMymenuService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateSysMymenulist.add(info);
					}
				}
			 else if("sys_myuser_group".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sSysMyuserGroup sInfo=new sSysMyuserGroup();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysMyuserGroup info=sSysMyuserGroupService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertSysMyuserGrouplist.add(info);
					}
					else if("delete".equals(operate))
					{
					  SysMyuserGroup info=new SysMyuserGroup();
					  int id=Integer.parseInt(idkey);
					  info.setIsid(id);
					  info.setSmId(ming);
					  deleteSysMyuserGrouplist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sSysMyuserGroup sInfo=new sSysMyuserGroup();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysMyuserGroup info=sSysMyuserGroupService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateSysMyuserGrouplist.add(info);
					}
				}
			 else if("sys_myuser_group_re".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sSysMyuserGroupRe sInfo=new sSysMyuserGroupRe();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysMyuserGroupRe info=sSysMyuserGroupReService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertSysMyuserGroupRelist.add(info);
					}
					else if("delete".equals(operate))
					{
					  SysMyuserGroupRe info=new SysMyuserGroupRe();
					  int id=Integer.parseInt(idkey);
					  info.setIsid(id);
					  info.setSmId(ming);
					  deleteSysMyuserGroupRelist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sSysMyuserGroupRe sInfo=new sSysMyuserGroupRe();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysMyuserGroupRe info=sSysMyuserGroupReService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateSysMyuserGroupRelist.add(info);
					}
				}
			 else if("sys_myuser".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sSysMyuser sInfo=new sSysMyuser();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysMyuser info=sSysMyuserService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertSysMyuserlist.add(info);
					}
					else if("delete".equals(operate))
					{
					  SysMyuser info=new SysMyuser();
					  int id=Integer.parseInt(idkey);
					  info.setIsid(id);
					  info.setSmId(ming);
					  deleteSysMyuserlist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sSysMyuser sInfo=new sSysMyuser();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysMyuser info=sSysMyuserService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateSysMyuserlist.add(info);
					}
				}
			 else if("sys_myuser_role".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sSysMyuserRole sInfo=new sSysMyuserRole();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysMyuserRole info=sSysMyuserRoleService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertSysMyuserRolelist.add(info);
					}
					else if("delete".equals(operate))
					{
					  SysMyuserRole info=new SysMyuserRole();
					  int id=Integer.parseInt(idkey);
					  info.setIsid(id);
					  info.setSmId(ming);
					  deleteSysMyuserRolelist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sSysMyuserRole sInfo=new sSysMyuserRole();
					  int id=Integer.parseInt(idkey);
					  sInfo.setIsid(id);
					  SysMyuserRole info=sSysMyuserRoleService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateSysMyuserRolelist.add(info);
					}
				}
			 else if("base_ladder_price_log".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sbaseLadderPriceLog sInfo=new sbaseLadderPriceLog();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  baseLadderPriceLog info=sbaseLadderPriceLogService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertbaseLadderPriceLoglist.add(info);
					}
					else if("delete".equals(operate))
					{
					  baseLadderPriceLog info=new baseLadderPriceLog();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deletebaseLadderPriceLoglist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sbaseLadderPriceLog sInfo=new sbaseLadderPriceLog();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  baseLadderPriceLog info=sbaseLadderPriceLogService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updatebaseLadderPriceLoglist.add(info);
					}
				}
			 else if("base_ladder_price".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sbaseLadderPrice sInfo=new sbaseLadderPrice();
					  sInfo.setGoodsNum(idkey);
					  baseLadderPrice info=sBaseLadderPriceService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertbaseLadderPricelist.add(info);
					}
					else if("delete".equals(operate))
					{
					  baseLadderPrice info=new baseLadderPrice();
					  info.setGoodsNum(idkey);
					  info.setSmId(ming);
					  deletebaseLadderPricelist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sbaseLadderPrice sInfo=new sbaseLadderPrice();
					  sInfo.setGoodsNum(idkey);
					  baseLadderPrice info=sBaseLadderPriceService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updatebaseLadderPricelist.add(info);
					}
				}
			 else if("base_memberday".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sbaseMemberday sInfo=new sbaseMemberday();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  baseMemberday info=sbaseMemberdayService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertbaseMemberdaylist.add(info);
					}
					else if("delete".equals(operate))
					{
					  baseMemberday info=new baseMemberday();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deletebaseMemberdaylist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sbaseMemberday sInfo=new sbaseMemberday();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  baseMemberday info=sbaseMemberdayService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updatebaseMemberdaylist.add(info);
					}
				}
			 else if("base_monthly_balance".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseMonthlyBalance sInfo=new sBaseMonthlyBalance();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseMonthlyBalance info=sBaseMonthlyBalanceService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBaseMonthlyBalancelist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseMonthlyBalance info=new BaseMonthlyBalance();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteBaseMonthlyBalancelist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseMonthlyBalance sInfo=new sBaseMonthlyBalance();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseMonthlyBalance info=sBaseMonthlyBalanceService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBaseMonthlyBalancelist.add(info);
					}
				}
			 else if("base_multi_item".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseMultiItem sInfo=new sBaseMultiItem();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseMultiItem info=sBaseMultiItemService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBaseMultiItemlist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseMultiItem info=new BaseMultiItem();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteBaseMultiItemlist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseMultiItem sInfo=new sBaseMultiItem();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseMultiItem info=sBaseMultiItemService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBaseMultiItemlist.add(info);
					}
				}
			 else if("base_parm_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseParmInfo sInfo=new sBaseParmInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseParmInfo info=sBaseParmInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBaseParmInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseParmInfo info=new BaseParmInfo();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteBaseParmInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseParmInfo sInfo=new sBaseParmInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseParmInfo info=sBaseParmInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBaseParmInfolist.add(info);
					}
				}
			 else if("order_instock_goods".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderInstockGoods sInfo=new sOrderInstockGoods();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderInstockGoods info=sOrderInstockGoodsService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderInstockGoodslist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderInstockGoods info=new OrderInstockGoods();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteOrderInstockGoodslist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderInstockGoods sInfo=new sOrderInstockGoods();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderInstockGoods info=sOrderInstockGoodsService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderInstockGoodslist.add(info);
					}
				}
			 else if("order_instock_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderInstockInfo sInfo=new sOrderInstockInfo();
					  sInfo.setOrderNum(idkey);
					  OrderInstockInfo info=sOrderInstockInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderInstockInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderInstockInfo info=new OrderInstockInfo();
					  info.setOrderNum(idkey);
					  info.setSmId(ming);
					  deleteOrderInstockInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderInstockInfo sInfo=new sOrderInstockInfo();
					  sInfo.setOrderNum(idkey);
					  OrderInstockInfo info=sOrderInstockInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderInstockInfolist.add(info);
					}
				}
			 else if("order_purchase_goods".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderPurchaseGoods sInfo=new sOrderPurchaseGoods();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderPurchaseGoods info=sOrderPurchaseGoodsService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderPurchaseGoodslist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderPurchaseGoods info=new OrderPurchaseGoods();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteOrderPurchaseGoodslist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderPurchaseGoods sInfo=new sOrderPurchaseGoods();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderPurchaseGoods info=sOrderPurchaseGoodsService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderPurchaseGoodslist.add(info);
					}
				}
			 else if("order_purchase_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderPurchaseInfo sInfo=new sOrderPurchaseInfo();
					  sInfo.setOrderNum(idkey);
					  OrderPurchaseInfo info=sOrderPurchaseInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderPurchaseInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderPurchaseInfo info=new OrderPurchaseInfo();
					  info.setOrderNum(idkey);
					  info.setSmId(ming);
					  deleteOrderPurchaseInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderPurchaseInfo sInfo=new sOrderPurchaseInfo();
					  sInfo.setOrderNum(idkey);
					  OrderPurchaseInfo info=sOrderPurchaseInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderPurchaseInfolist.add(info);
					}
				}
			 else if("base_supplier_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseSupplierInfo sInfo=new sBaseSupplierInfo();
					  sInfo.setSupplierCode(idkey);
					  BaseSupplierInfo info=sBaseSupplierInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBaseSupplierInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseSupplierInfo info=new BaseSupplierInfo();
					  info.setSupplierCode(idkey);
					  info.setSmId(ming);
					  deleteBaseSupplierInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseSupplierInfo sInfo=new sBaseSupplierInfo();
					  sInfo.setSupplierCode(idkey);
					  BaseSupplierInfo info=sBaseSupplierInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBaseSupplierInfolist.add(info);
					}
				}
			 else if("base_promotion_info_log".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBasePromotionInfoLog sInfo=new sBasePromotionInfoLog();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BasePromotionInfoLog info=sBasePromotionInfoLogService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBasePromotionInfoLoglist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BasePromotionInfoLog info=new BasePromotionInfoLog();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteBasePromotionInfoLoglist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBasePromotionInfoLog sInfo=new sBasePromotionInfoLog();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BasePromotionInfoLog info=sBasePromotionInfoLogService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBasePromotionInfoLoglist.add(info);
					}
				}
			 else if("base_promotion_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBasePromotionInfo sInfo=new sBasePromotionInfo();
					 // int id=Integer.parseInt(idkey);
					  sInfo.setGoodsNum(idkey);
					  BasePromotionInfo info=sBasePromotionInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBasePromotionInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BasePromotionInfo info=new BasePromotionInfo();
					 // int id=Integer.parseInt(idkey);
					  info.setGoodsNum(idkey);
					  info.setSmId(ming);
					  deleteBasePromotionInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBasePromotionInfo sInfo=new sBasePromotionInfo();
					 // int id=Integer.parseInt(idkey);
					  sInfo.setGoodsNum(idkey);
					  BasePromotionInfo info=sBasePromotionInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBasePromotionInfolist.add(info);
					}
				}
			 else if("base_vouchers_log".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseVouchersLog sInfo=new sBaseVouchersLog();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseVouchersLog info=sBaseVouchersLogService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBaseVouchersLoglist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseVouchersLog info=new BaseVouchersLog();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteBaseVouchersLoglist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseVouchersLog sInfo=new sBaseVouchersLog();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseVouchersLog info=sBaseVouchersLogService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBaseVouchersLoglist.add(info);
					}
				}
			 else if("base_vouchers_log".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sBaseVouchers sInfo=new sBaseVouchers();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseVouchers info=sBaseVouchersService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertBaseVoucherslist.add(info);
					}
					else if("delete".equals(operate))
					{
					  BaseVouchers info=new BaseVouchers();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteBaseVoucherslist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sBaseVouchers sInfo=new sBaseVouchers();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  BaseVouchers info=sBaseVouchersService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateBaseVoucherslist.add(info);
					}
				}
			 else if("daily_Goods_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sDailyGoodsInfo sInfo=new sDailyGoodsInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  DailyGoodsInfo info=sDailyGoodsInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertDailyGoodsInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  DailyGoodsInfo info=new DailyGoodsInfo();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteDailyGoodsInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sDailyGoodsInfo sInfo=new sDailyGoodsInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  DailyGoodsInfo info=sDailyGoodsInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateDailyGoodsInfolist.add(info);
					}
				}
			 else if("daily_GoodsType_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sDailyGoodstypeInfo sInfo=new sDailyGoodstypeInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  DailyGoodstypeInfo info=sDailyGoodstypeInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertDailyGoodstypeInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  DailyGoodstypeInfo info=new DailyGoodstypeInfo();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteDailyGoodstypeInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sDailyGoodstypeInfo sInfo=new sDailyGoodstypeInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  DailyGoodstypeInfo info=sDailyGoodstypeInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateDailyGoodstypeInfolist.add(info);
					}
				}
			 else if("daily_saleamount_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sDailySaleamountInfo sInfo=new sDailySaleamountInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  DailySaleamountInfo info=sDailySaleamountInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertDailySaleamountInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  DailySaleamountInfo info=new DailySaleamountInfo();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteDailySaleamountInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sDailySaleamountInfo sInfo=new sDailySaleamountInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  DailySaleamountInfo info=sDailySaleamountInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateDailySaleamountInfolist.add(info);
					}
				}
			 else if("daily_SupplierSale_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sDailySuppliersaleInfo sInfo=new sDailySuppliersaleInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  DailySuppliersaleInfo info=sDailySuppliersaleInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertDailySuppliersaleInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  DailySuppliersaleInfo info=new DailySuppliersaleInfo();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteDailySuppliersaleInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sDailySuppliersaleInfo sInfo=new sDailySuppliersaleInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  DailySuppliersaleInfo info=sDailySuppliersaleInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateDailySuppliersaleInfolist.add(info);
					}
				}
			 else if("monly_goods_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sMonlyGoodsInfo sInfo=new sMonlyGoodsInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  MonlyGoodsInfo info=sMonlyGoodsInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertMonlyGoodsInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  MonlyGoodsInfo info=new MonlyGoodsInfo();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteMonlyGoodsInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sMonlyGoodsInfo sInfo=new sMonlyGoodsInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  MonlyGoodsInfo info=sMonlyGoodsInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateMonlyGoodsInfolist.add(info);
					}
				}
			 else if("monly_goods_type".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sMonlyGoodsType sInfo=new sMonlyGoodsType();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  MonlyGoodsType info=sMonlyGoodsTypeService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertMonlyGoodsTypelist.add(info);
					}
					else if("delete".equals(operate))
					{
					  MonlyGoodsType info=new MonlyGoodsType();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteMonlyGoodsTypelist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sMonlyGoodsType sInfo=new sMonlyGoodsType();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  MonlyGoodsType info=sMonlyGoodsTypeService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateMonlyGoodsTypelist.add(info);
					}
				}
			 else if("monly_saleamount_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sMonlySaleamountInfo sInfo=new sMonlySaleamountInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  MonlySaleamountInfo info=sMonlySaleamountInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertMonlySaleamountInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  MonlySaleamountInfo info=new MonlySaleamountInfo();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteMonlySaleamountInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sMonlySaleamountInfo sInfo=new sMonlySaleamountInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  MonlySaleamountInfo info=sMonlySaleamountInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateMonlySaleamountInfolist.add(info);
					}
				}
			 else if("monly_SupplierSale_info".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sMonlySuppliersaleInfo sInfo=new sMonlySuppliersaleInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  MonlySuppliersaleInfo info=sMonlySuppliersaleInfoService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertMonlySuppliersaleInfolist.add(info);
					}
					else if("delete".equals(operate))
					{
					  MonlySuppliersaleInfo info=new MonlySuppliersaleInfo();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteMonlySuppliersaleInfolist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sMonlySuppliersaleInfo sInfo=new sMonlySuppliersaleInfo();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  MonlySuppliersaleInfo info=sMonlySuppliersaleInfoService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateMonlySuppliersaleInfolist.add(info);
					}
				}
			 else if("order_instock_modify_log".equals(Biaoming))
				{
					if("inserted".equals(operate))
					{ 
					  sOrderInstockModifyLog sInfo=new sOrderInstockModifyLog();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderInstockModifyLog info=sOrderInstockModifyLogService.selectInfo(sInfo);
					  info.setSmId(ming);					  
					  insertOrderInstockModifyLoglist.add(info);
					}
					else if("delete".equals(operate))
					{
					  OrderInstockModifyLog info=new OrderInstockModifyLog();
					  int id=Integer.parseInt(idkey);
					  info.setId(id);
					  info.setSmId(ming);
					  deleteOrderInstockModifyLoglist.add(info);
					}
					else if("updated".equals(operate))
					{
					  sOrderInstockModifyLog sInfo=new sOrderInstockModifyLog();
					  int id=Integer.parseInt(idkey);
					  sInfo.setId(id);
					  OrderInstockModifyLog info=sOrderInstockModifyLogService.selectInfo(sInfo);
					  info.setSmId(ming);
					  updateOrderInstockModifyLoglist.add(info);
					}
				}
			//endregion
			
			}
				 catch (Exception e) {  
			          
					 int tongbuid=tlist.get(i).getId();
					  Service.updateState(tongbuid);  
			       }
			//FIXME 	
		    }
		  }
		 //region	 判空he封装	 
		 if(insertxinXibiaolist.size()!=0)
		 {
		 insertmap.put("xinXibiao", insertxinXibiaolist);
		 }
		 if(updatexinXibiaolist.size()!=0)
		 {
		updatemap.put("xinXibiao", updatexinXibiaolist); 
		 }
		 
		 if(insertorderGoodsInfolist.size()!=0)
		 {
		 insertmap.put("orderGoodsInfo", insertorderGoodsInfolist);
		 }
		 if(deleteorderGoodsInfolist.size()!=0)
		 {
		deletemap.put("orderGoodsInfo", deleteorderGoodsInfolist); 
		 }
		 if(updateorderGoodsInfolist.size()!=0)
		 {
		updatemap.put("orderGoodsInfo", updateorderGoodsInfolist); 
		 }
		 
		 if(insertOrderGoodsListlist.size()!=0)
		 {
		 insertmap.put("OrderGoodsList", insertOrderGoodsListlist);
		 }
		 if(deleteOrderGoodsListlist.size()!=0)
		 {
		deletemap.put("OrderGoodsList", deleteOrderGoodsListlist); 
		 }
		 if(updateOrderGoodsListlist.size()!=0)
		 {
		updatemap.put("OrderGoodsList", updateOrderGoodsListlist); 
		 }
		 
		 if(insertBaseChargeInfolist.size()!=0)
		 {
		 insertmap.put("BaseChargeInfo", insertBaseChargeInfolist);
		 }
		 if(deleteBaseChargeInfolist.size()!=0)
		 {
		deletemap.put("BaseChargeInfo", deleteBaseChargeInfolist); 
		 }
		 if(updateBaseChargeInfolist.size()!=0)
		 {
		updatemap.put("BaseChargeInfo", updateBaseChargeInfolist); 
		 }
		 
		 if(insertBaseCustomerInfolist.size()!=0)
		 {
		 insertmap.put("BaseCustomerInfo", insertBaseCustomerInfolist);
		 }
		 if(deleteBaseCustomerInfolist.size()!=0)
		 {
		 deletemap.put("BaseCustomerInfo", deleteBaseCustomerInfolist); 
		 }
		 if(updateBaseCustomerInfolist.size()!=0)
		 {
		 updatemap.put("BaseCustomerInfo", updateBaseCustomerInfolist); 
		 }
		 
		 if(insertBaseGoodsInfolist.size()!=0)
		 {
		 insertmap.put("BaseGoodsInfo", insertBaseGoodsInfolist);
		 }
		 if(deleteBaseGoodsInfolist.size()!=0)
		 {
		 deletemap.put("BaseGoodsInfo", deleteBaseGoodsInfolist); 
		 }
		 if(updateBaseGoodsInfolist.size()!=0)
		 {
		 updatemap.put("BaseGoodsInfo", updateBaseGoodsInfolist); 
		 }
		 
		 if(insertBaseGoodsStocklist.size()!=0)
		 {
		 insertmap.put("BaseGoodsStock", insertBaseGoodsStocklist);
		 }
		 if(deleteBaseGoodsStocklist.size()!=0)
		 {
		 deletemap.put("BaseGoodsStock", deleteBaseGoodsStocklist); 
		 }
		 if(updateBaseGoodsStocklist.size()!=0)
		 {
		 updatemap.put("BaseGoodsStock", updateBaseGoodsStocklist); 
		 }
		 
		 if(insertBaseGoodsUnitlist.size()!=0)
		 {
		 insertmap.put("BaseGoodsUnit", insertBaseGoodsUnitlist);
		 }
		 if(deleteBaseGoodsUnitlist.size()!=0)
		 {
		 deletemap.put("BaseGoodsUnit", deleteBaseGoodsUnitlist); 
		 }
		 if(updateBaseGoodsUnitlist.size()!=0)
		 {
		 updatemap.put("BaseGoodsUnit", updateBaseGoodsUnitlist); 
		 }
		 
		 if(insertBaseMemberInfolist.size()!=0)
		 {
		 insertmap.put("BaseMemberInfo", insertBaseMemberInfolist);
		 }
		 if(deleteBaseMemberInfolist.size()!=0)
		 {
		 deletemap.put("BaseMemberInfo", deleteBaseMemberInfolist); 
		 }
		 if(updateBaseMemberInfolist.size()!=0)
		 {
		 updatemap.put("BaseMemberInfo", updateBaseMemberInfolist); 
		 }
		 
		 if(insertBaseMemberLoglist.size()!=0)
		 {
		 insertmap.put("BaseMemberLog", insertBaseMemberLoglist);
		 }
		 if(deleteBaseMemberLoglist.size()!=0)
		 {
		 deletemap.put("BaseMemberLog", deleteBaseMemberLoglist); 
		 }
		 if(updateBaseMemberLoglist.size()!=0)
		 {
		 updatemap.put("BaseMemberLog", updateBaseMemberLoglist); 
		 }
		 
		 if(insertBaseScalesInfolist.size()!=0)
		 {
		 insertmap.put("BaseScalesInfo", insertBaseScalesInfolist);
		 }
		 if(deleteBaseScalesInfolist.size()!=0)
		 {
		 deletemap.put("BaseScalesInfo", deleteBaseScalesInfolist); 
		 }
		 if(updateBaseScalesInfolist.size()!=0)
		 {
		 updatemap.put("BaseScalesInfo", updateBaseScalesInfolist); 
		 }
		 
		 if(insertBaseScalesInfolist.size()!=0)
		 {
		 insertmap.put("BaseScalesInfo", insertBaseScalesInfolist);
		 }
		 if(deleteBaseScalesInfolist.size()!=0)
		 {
		 deletemap.put("BaseScalesInfo", deleteBaseScalesInfolist); 
		 }
		 if(updateBaseScalesInfolist.size()!=0)
		 {
		 updatemap.put("BaseScalesInfo", updateBaseScalesInfolist); 
		 }
		 
		 if(insertBaseShopInfolist.size()!=0)
		 {
		 insertmap.put("BaseShopInfo", insertBaseShopInfolist);
		 }
		 if(deleteBaseShopInfolist.size()!=0)
		 {
		 deletemap.put("BaseShopInfo", deleteBaseShopInfolist); 
		 }
		 if(updateBaseShopInfolist.size()!=0)
		 {
		 updatemap.put("BaseShopInfo", updateBaseShopInfolist); 
		 }
		 
		 if(insertBaseSpecialPriceLoglist.size()!=0)
		 {
		 insertmap.put("BaseSpecialPriceLog", insertBaseSpecialPriceLoglist);
		 }
		 if(deleteBaseSpecialPriceLoglist.size()!=0)
		 {
		 deletemap.put("BaseSpecialPriceLog", deleteBaseSpecialPriceLoglist); 
		 }
		 if(updateBaseSpecialPriceLoglist.size()!=0)
		 {
		 updatemap.put("BaseSpecialPriceLog", updateBaseSpecialPriceLoglist); 
		 }
		 
		 if(insertBaseSpecialPricelist.size()!=0)
		 {
		 insertmap.put("BaseSpecialPrice", insertBaseSpecialPricelist);
		 }
		 if(deleteBaseSpecialPricelist.size()!=0)
		 {
		 deletemap.put("BaseSpecialPrice", deleteBaseSpecialPricelist); 
		 }
		 if(updateBaseSpecialPricelist.size()!=0)
		 {
		 updatemap.put("BaseSpecialPrice", updateBaseSpecialPricelist); 
		 }
		 
		 if(insertBaseSpecialThemegoodslist.size()!=0)
		 {
		 insertmap.put("BaseSpecialThemegoods", insertBaseSpecialThemegoodslist);
		 }
		 if(deleteBaseSpecialThemegoodslist.size()!=0)
		 {
		 deletemap.put("BaseSpecialThemegoods", deleteBaseSpecialThemegoodslist); 
		 }
		 if(updateBaseSpecialThemegoodslist.size()!=0)
		 {
		 updatemap.put("BaseSpecialThemegoods", updateBaseSpecialThemegoodslist); 
		 }
		 
		 if(insertBaseSpecialThemelist.size()!=0)
		 {
		 insertmap.put("BaseSpecialTheme", insertBaseSpecialThemelist);
		 }
		 if(deleteBaseSpecialThemelist.size()!=0)
		 {
		 deletemap.put("BaseSpecialTheme", deleteBaseSpecialThemelist); 
		 }
		 if(updateBaseSpecialThemelist.size()!=0)
		 {
		 updatemap.put("BaseSpecialTheme", updateBaseSpecialThemelist); 
		 }
		
		 if(insertBaseSupplierPaytypelist.size()!=0)
		 {
		 insertmap.put("BaseSupplierPaytype", insertBaseSupplierPaytypelist);
		 }
		 if(deleteBaseSupplierPaytypelist.size()!=0)
		 {
		 deletemap.put("BaseSupplierPaytype", deleteBaseSupplierPaytypelist); 
		 }
		 if(updateBaseSupplierPaytypelist.size()!=0)
		 {
		 updatemap.put("BaseSupplierPaytype", updateBaseSupplierPaytypelist); 
		 }
		 
		 if(insertBaseTypeInfolist.size()!=0)
		 {
		 insertmap.put("BaseTypeInfo", insertBaseTypeInfolist);
		 }
		 if(deleteBaseTypeInfolist.size()!=0)
		 {
		 deletemap.put("BaseTypeInfo", deleteBaseTypeInfolist); 
		 }
		 if(updateBaseTypeInfolist.size()!=0)
		 {
		 updatemap.put("BaseTypeInfo", updateBaseTypeInfolist); 
		 }
		 
		 if(insertBaseValuecardInfolist.size()!=0)
		 {
		 insertmap.put("BaseValuecardInfo", insertBaseValuecardInfolist);
		 }
		 if(deleteBaseValuecardInfolist.size()!=0)
		 {
		 deletemap.put("BaseValuecardInfo", deleteBaseValuecardInfolist); 
		 }
		 if(updateBaseValuecardInfolist.size()!=0)
		 {
		 updatemap.put("BaseValuecardInfo", updateBaseValuecardInfolist); 
		 }
		 
		 if(insertBaseValuecardLoglist.size()!=0)
		 {
		 insertmap.put("BaseValuecardLog", insertBaseValuecardLoglist);
		 }
		 if(deleteBaseValuecardLoglist.size()!=0)
		 {
		 deletemap.put("BaseValuecardLog", deleteBaseValuecardLoglist); 
		 }
		 if(updateBaseValuecardLoglist.size()!=0)
		 {
		 updatemap.put("BaseValuecardLog", updateBaseValuecardLoglist); 
		 }
		 
		 if(insertBaseVillagelist.size()!=0)
		 {
		 insertmap.put("BaseVillage", insertBaseVillagelist);
		 }
		 if(deleteBaseVillagelist.size()!=0)
		 {
		 deletemap.put("BaseVillage", deleteBaseVillagelist); 
		 }
		 if(updateBaseVillagelist.size()!=0)
		 {
		 updatemap.put("BaseVillage", updateBaseVillagelist); 
		 }
		 
		 if(insertBaseWarehouseInfolist.size()!=0)
		 {
		 insertmap.put("BaseWarehouseInfo", insertBaseWarehouseInfolist);
		 }
		 if(deleteBaseWarehouseInfolist.size()!=0)
		 {
		 deletemap.put("BaseWarehouseInfo", deleteBaseWarehouseInfolist); 
		 }
		 if(updateBaseWarehouseInfolist.size()!=0)
		 {
		 updatemap.put("BaseWarehouseInfo", updateBaseWarehouseInfolist); 
		 }
		 
		 if(insertBaseWebVillagelist.size()!=0)
		 {
		 insertmap.put("BaseWebVillage", insertBaseWebVillagelist);
		 }
		 if(deleteBaseWebVillagelist.size()!=0)
		 {
		 deletemap.put("BaseWebVillage", deleteBaseWebVillagelist); 
		 }
		 if(updateBaseWebVillagelist.size()!=0)
		 {
		 updatemap.put("BaseWebVillage", updateBaseWebVillagelist); 
		 }
		 
		 if(insertOrderAllotGoodslist.size()!=0)
		 {
		 insertmap.put("OrderAllotGoods", insertOrderAllotGoodslist);
		 }
		 if(deleteOrderAllotGoodslist.size()!=0)
		 {
		 deletemap.put("OrderAllotGoods", deleteOrderAllotGoodslist); 
		 }
		 if(updateOrderAllotGoodslist.size()!=0)
		 {
		 updatemap.put("OrderAllotGoods", updateOrderAllotGoodslist); 
		 }
		 
		 if(insertOrderAllotInfolist.size()!=0)
		 {
		 insertmap.put("OrderAllotInfo", insertOrderAllotInfolist);
		 }
		 if(deleteOrderAllotInfolist.size()!=0)
		 {
		 deletemap.put("OrderAllotInfo", deleteOrderAllotInfolist); 
		 }
		 if(updateOrderAllotInfolist.size()!=0)
		 {
		 updatemap.put("OrderAllotInfo", updateOrderAllotInfolist); 
		 }
		 
		 if(insertOrderBigsaleGoodslist.size()!=0)
		 {
		 insertmap.put("OrderBigsaleGoods", insertOrderBigsaleGoodslist);
		 }
		 if(deleteOrderBigsaleGoodslist.size()!=0)
		 {
		 deletemap.put("OrderBigsaleGoods", deleteOrderBigsaleGoodslist); 
		 }
		 if(updateOrderBigsaleGoodslist.size()!=0)
		 {
		 updatemap.put("OrderBigsaleGoods", updateOrderBigsaleGoodslist); 
		 }
		 
		 if(insertOrderBigsaleInfolist.size()!=0)
		 {
		 insertmap.put("OrderBigsaleInfo", insertOrderBigsaleInfolist);
		 }
		 if(deleteOrderBigsaleInfolist.size()!=0)
		 {
		 deletemap.put("OrderBigsaleInfo", deleteOrderBigsaleInfolist); 
		 }
		 if(updateOrderBigsaleInfolist.size()!=0)
		 {
		 updatemap.put("OrderBigsaleInfo", updateOrderBigsaleInfolist); 
		 }
		 
		 if(insertOrderBreakageGoodslist.size()!=0)
		 {
		 insertmap.put("OrderBreakageGoods", insertOrderBreakageGoodslist);
		 }
		 if(deleteOrderBreakageGoodslist.size()!=0)
		 {
		 deletemap.put("OrderBreakageGoods", deleteOrderBreakageGoodslist); 
		 }
		 if(updateOrderBreakageGoodslist.size()!=0)
		 {
		 updatemap.put("OrderBreakageGoods", updateOrderBreakageGoodslist); 
		 }
		 
		 if(insertOrderBreakageInfolist.size()!=0)
		 {
		 insertmap.put("OrderBreakageInfo", insertOrderBreakageInfolist);
		 }
		 if(deleteOrderBreakageInfolist.size()!=0)
		 {
		 deletemap.put("OrderBreakageInfo", deleteOrderBreakageInfolist); 
		 }
		 if(updateOrderBreakageInfolist.size()!=0)
		 {
		 updatemap.put("OrderBreakageInfo", updateOrderBreakageInfolist); 
		 }
		 
		 if(insertOrderCollectionInfolist.size()!=0)
		 {
		 insertmap.put("OrderCollectionInfo", insertOrderCollectionInfolist);
		 }
		 if(deleteOrderCollectionInfolist.size()!=0)
		 {
		 deletemap.put("OrderCollectionInfo", deleteOrderCollectionInfolist); 
		 }
		 if(updateOrderCollectionInfolist.size()!=0)
		 {
		 updatemap.put("OrderCollectionInfo", updateOrderCollectionInfolist); 
		 }
		 
		 if(insertOrderCollectionListlist.size()!=0)
		 {
		 insertmap.put("OrderCollectionList", insertOrderCollectionListlist);
		 }
		 if(deleteOrderCollectionListlist.size()!=0)
		 {
		 deletemap.put("OrderCollectionList", deleteOrderCollectionListlist); 
		 }
		 if(updateOrderCollectionListlist.size()!=0)
		 {
		 updatemap.put("OrderCollectionList", updateOrderCollectionListlist); 
		 }
		 
		 if(insertOrderDeductmoneyGoodslist.size()!=0)
		 {
		 insertmap.put("OrderDeductmoneyGoods", insertOrderDeductmoneyGoodslist);
		 }
		 if(deleteOrderDeductmoneyGoodslist.size()!=0)
		 {
		 deletemap.put("OrderDeductmoneyGoods", deleteOrderDeductmoneyGoodslist); 
		 }
		 if(updateOrderDeductmoneyGoodslist.size()!=0)
		 {
		 updatemap.put("OrderDeductmoneyGoods", updateOrderDeductmoneyGoodslist); 
		 }
		 
		 if(insertOrderDeductmoneyInfolist.size()!=0)
		 {
		 insertmap.put("OrderDeductmoneyInfo", insertOrderDeductmoneyInfolist);
		 }
		 if(deleteOrderDeductmoneyInfolist.size()!=0)
		 {
		 deletemap.put("OrderDeductmoneyInfo", deleteOrderDeductmoneyInfolist); 
		 }
		 if(updateOrderDeductmoneyInfolist.size()!=0)
		 {
		 updatemap.put("OrderDeductmoneyInfo", updateOrderDeductmoneyInfolist); 
		 }
		 
		 if(insertOrderDelayGoodslistlist.size()!=0)
		 {
		 insertmap.put("OrderDelayGoodslist", insertOrderDelayGoodslistlist);
		 }
		 if(deleteOrderDelayGoodslistlist.size()!=0)
		 {
		 deletemap.put("OrderDelayGoodslist", deleteOrderDelayGoodslistlist); 
		 }
		 if(updateOrderDelayGoodslistlist.size()!=0)
		 {
		 updatemap.put("OrderDelayGoodslist", updateOrderDelayGoodslistlist); 
		 }
		 
		 if(insertOrderDelayInfolist.size()!=0)
		 {
		 insertmap.put("OrderDelayInfo", insertOrderDelayInfolist);
		 }
		 if(deleteOrderDelayInfolist.size()!=0)
		 {
		 deletemap.put("OrderDelayInfo", deleteOrderDelayInfolist); 
		 }
		 if(updateOrderDelayInfolist.size()!=0)
		 {
		 updatemap.put("OrderDelayInfo", updateOrderDelayInfolist); 
		 }
		 
		 if(insertOrderFreegoodsInfolist.size()!=0)
		 {
		 insertmap.put("OrderFreegoodsInfo", insertOrderFreegoodsInfolist);
		 }
		 if(deleteOrderFreegoodsInfolist.size()!=0)
		 {
		 deletemap.put("OrderFreegoodsInfo", deleteOrderFreegoodsInfolist); 
		 }
		 if(updateOrderFreegoodsInfolist.size()!=0)
		 {
		 updatemap.put("OrderFreegoodsInfo", updateOrderFreegoodsInfolist); 
		 }
		 
		 if(insertOrderFreegoodsListlist.size()!=0)
		 {
		 insertmap.put("OrderFreegoodsList", insertOrderFreegoodsListlist);
		 }
		 if(deleteOrderFreegoodsListlist.size()!=0)
		 {
		 deletemap.put("OrderFreegoodsList", deleteOrderFreegoodsListlist); 
		 }
		 if(updateOrderFreegoodsListlist.size()!=0)
		 {
		 updatemap.put("OrderFreegoodsList", updateOrderFreegoodsListlist); 
		 }
		 
		 if(insertOrderHandinInfolist.size()!=0)
		 {
		 insertmap.put("OrderHandinInfo", insertOrderHandinInfolist);
		 }
		 if(deleteOrderHandinInfolist.size()!=0)
		 {
		 deletemap.put("OrderHandinInfo", deleteOrderHandinInfolist); 
		 }
		 if(updateOrderHandinInfolist.size()!=0)
		 {
		 updatemap.put("OrderHandinInfo", updateOrderHandinInfolist); 
		 }
		 
		 if(insertOrderHandinListlist.size()!=0)
		 {
		 insertmap.put("OrderHandinList", insertOrderHandinListlist);
		 }
		 if(deleteOrderHandinListlist.size()!=0)
		 {
		 deletemap.put("OrderHandinList", deleteOrderHandinListlist); 
		 }
		 if(updateOrderHandinListlist.size()!=0)
		 {
		 updatemap.put("OrderHandinList", updateOrderHandinListlist); 
		 }
		 
		 if(insertOrderInterioruseGoodslist.size()!=0)
		 {
		 insertmap.put("OrderInterioruseGoods", insertOrderInterioruseGoodslist);
		 }
		 if(deleteOrderInterioruseGoodslist.size()!=0)
		 {
		 deletemap.put("OrderInterioruseGoods", deleteOrderInterioruseGoodslist); 
		 }
		 if(updateOrderInterioruseGoodslist.size()!=0)
		 {
		 updatemap.put("OrderInterioruseGoods", updateOrderInterioruseGoodslist); 
		 }
		 
		 if(insertOrderInterioruseInfolist.size()!=0)
		 {
		 insertmap.put("OrderInterioruseInfo", insertOrderInterioruseInfolist);
		 }
		 if(deleteOrderInterioruseInfolist.size()!=0)
		 {
		 deletemap.put("OrderInterioruseInfo", deleteOrderInterioruseInfolist); 
		 }
		 if(updateOrderInterioruseInfolist.size()!=0)
		 {
		 updatemap.put("OrderInterioruseInfo", updateOrderInterioruseInfolist); 
		 }
		 
		 if(insertOrderInventoryGoodslist.size()!=0)
		 {
		 insertmap.put("OrderInventoryGoods", insertOrderInventoryGoodslist);
		 }
		 if(deleteOrderInventoryGoodslist.size()!=0)
		 {
		 deletemap.put("OrderInventoryGoods", deleteOrderInventoryGoodslist); 
		 }
		 if(updateOrderInventoryGoodslist.size()!=0)
		 {
		 updatemap.put("OrderInventoryGoods", updateOrderInventoryGoodslist); 
		 }
		 
		 if(insertOrderInventoryGrouplist.size()!=0)
		 {
		 insertmap.put("OrderInventoryGroup", insertOrderInventoryGrouplist);
		 }
		 if(deleteOrderInventoryGrouplist.size()!=0)
		 {
		 deletemap.put("OrderInventoryGroup", deleteOrderInventoryGrouplist); 
		 }
		 if(updateOrderInventoryGrouplist.size()!=0)
		 {
		 updatemap.put("OrderInventoryGroup", updateOrderInventoryGrouplist); 
		 }
		 
		 if(insertOrderInventoryInfolist.size()!=0)
		 {
		 insertmap.put("OrderInventoryInfo", insertOrderInventoryInfolist);
		 }
		 if(deleteOrderInventoryInfolist.size()!=0)
		 {
		 deletemap.put("OrderInventoryInfo", deleteOrderInventoryInfolist); 
		 }
		 if(updateOrderInventoryInfolist.size()!=0)
		 {
		 updatemap.put("OrderInventoryInfo", updateOrderInventoryInfolist); 
		 }
		 
		 if(insertOrderInventoryPersonlist.size()!=0)
		 {
		 insertmap.put("OrderInventoryPerson", insertOrderInventoryPersonlist);
		 }
		 if(deleteOrderInventoryPersonlist.size()!=0)
		 {
		 deletemap.put("OrderInventoryPerson", deleteOrderInventoryPersonlist); 
		 }
		 if(updateOrderInventoryPersonlist.size()!=0)
		 {
		 updatemap.put("OrderInventoryPerson", updateOrderInventoryPersonlist); 
		 }
		 
		 if(insertOrderOutstockGoodslist.size()!=0)
		 {
		 insertmap.put("OrderOutstockGoods", insertOrderOutstockGoodslist);
		 }
		 if(deleteOrderOutstockGoodslist.size()!=0)
		 {
		 deletemap.put("OrderOutstockGoods", deleteOrderOutstockGoodslist); 
		 }
		 if(updateOrderOutstockGoodslist.size()!=0)
		 {
		 updatemap.put("OrderOutstockGoods", updateOrderOutstockGoodslist); 
		 }
		 
		 if(insertOrderOutstockInfolist.size()!=0)
		 {
		 insertmap.put("OrderOutstockInfo", insertOrderOutstockInfolist);
		 }
		 if(deleteOrderOutstockInfolist.size()!=0)
		 {
		 deletemap.put("OrderOutstockInfo", deleteOrderOutstockInfolist); 
		 }
		 if(updateOrderOutstockInfolist.size()!=0)
		 {
		 updatemap.put("OrderOutstockInfo", updateOrderOutstockInfolist); 
		 }
		 
		 if(insertOrderPaymentInfolist.size()!=0)
		 {
		 insertmap.put("OrderPaymentInfo", insertOrderPaymentInfolist);
		 }
		 if(deleteOrderPaymentInfolist.size()!=0)
		 {
		 deletemap.put("OrderPaymentInfo", deleteOrderPaymentInfolist); 
		 }
		 if(updateOrderPaymentInfolist.size()!=0)
		 {
		 updatemap.put("OrderPaymentInfo", updateOrderPaymentInfolist); 
		 }
		 
		 if(insertOrderPaymentListlist.size()!=0)
		 {
		 insertmap.put("OrderPaymentList", insertOrderPaymentListlist);
		 }
		 if(deleteOrderPaymentListlist.size()!=0)
		 {
		 deletemap.put("OrderPaymentList", deleteOrderPaymentListlist); 
		 }
		 if(updateOrderPaymentListlist.size()!=0)
		 {
		 updatemap.put("OrderPaymentList", updateOrderPaymentListlist); 
		 }
		 
		 if(insertOrderPoolPaymentInfolist.size()!=0)
		 {
		 insertmap.put("OrderPoolPaymentInfo", insertOrderPoolPaymentInfolist);
		 }
		 if(deleteOrderPoolPaymentInfolist.size()!=0)
		 {
		 deletemap.put("OrderPoolPaymentInfo", deleteOrderPoolPaymentInfolist); 
		 }
		 if(updateOrderPoolPaymentInfolist.size()!=0)
		 {
		 updatemap.put("OrderPoolPaymentInfo", updateOrderPoolPaymentInfolist); 
		 }
		 
		 if(insertOrderPoolPaymentListlist.size()!=0)
		 {
		 insertmap.put("OrderPoolPaymentList", insertOrderPoolPaymentListlist);
		 }
		 if(deleteOrderPoolPaymentListlist.size()!=0)
		 {
		 deletemap.put("OrderPoolPaymentList", deleteOrderPoolPaymentListlist); 
		 }
		 if(updateOrderPoolPaymentListlist.size()!=0)
		 {
		 updatemap.put("OrderPoolPaymentList", updateOrderPoolPaymentListlist); 
		 }
		 
		 if(insertOrderPoolSettlementInfolist.size()!=0)
		 {
		 insertmap.put("OrderPoolSettlementInfo", insertOrderPoolSettlementInfolist);
		 }
		 if(deleteOrderPoolSettlementInfolist.size()!=0)
		 {
		 deletemap.put("OrderPoolSettlementInfo", deleteOrderPoolSettlementInfolist); 
		 }
		 if(updateOrderPoolSettlementInfolist.size()!=0)
		 {
		 updatemap.put("OrderPoolSettlementInfo", updateOrderPoolSettlementInfolist); 
		 }
		 
		 if(insertOrderProcurementGoodslist.size()!=0)
		 {
		 insertmap.put("OrderProcurementGoods", insertOrderProcurementGoodslist);
		 }
		 if(deleteOrderProcurementGoodslist.size()!=0)
		 {
		 deletemap.put("OrderProcurementGoods", deleteOrderProcurementGoodslist); 
		 }
		 if(updateOrderProcurementGoodslist.size()!=0)
		 {
		 updatemap.put("OrderProcurementGoods", updateOrderProcurementGoodslist); 
		 }
		 
		 if(insertOrderProcurementInfolist.size()!=0)
		 {
		 insertmap.put("OrderProcurementInfo", insertOrderProcurementInfolist);
		 }
		 if(deleteOrderProcurementInfolist.size()!=0)
		 {
		 deletemap.put("OrderProcurementInfo", deleteOrderProcurementInfolist); 
		 }
		 if(updateOrderProcurementInfolist.size()!=0)
		 {
		 updatemap.put("OrderProcurementInfo", updateOrderProcurementInfolist); 
		 }
		 
		 if(insertOrderReturnGoodslistlist.size()!=0)
		 {
		 insertmap.put("OrderReturnGoodslist", insertOrderReturnGoodslistlist);
		 }
		 if(deleteOrderReturnGoodslistlist.size()!=0)
		 {
		 deletemap.put("OrderReturnGoodslist", deleteOrderReturnGoodslistlist); 
		 }
		 if(updateOrderReturnGoodslistlist.size()!=0)
		 {
		 updatemap.put("OrderReturnGoodslist", updateOrderReturnGoodslistlist); 
		 }
		 
		 if(insertOrderReturnInfolist.size()!=0)
		 {
		 insertmap.put("OrderReturnInfo", insertOrderReturnInfolist);
		 }
		 if(deleteOrderReturnInfolist.size()!=0)
		 {
		 deletemap.put("OrderReturnInfo", deleteOrderReturnInfolist); 
		 }
		 if(updateOrderReturnInfolist.size()!=0)
		 {
		 updatemap.put("OrderReturnInfo", updateOrderReturnInfolist); 
		 }
		 
		 if(insertOrderSchargeInfolist.size()!=0)
		 {
		 insertmap.put("OrderSchargeInfo", insertOrderSchargeInfolist);
		 }
		 if(deleteOrderSchargeInfolist.size()!=0)
		 {
		 deletemap.put("OrderSchargeInfo", deleteOrderSchargeInfolist); 
		 }
		 if(updateOrderSchargeInfolist.size()!=0)
		 {
		 updatemap.put("OrderSchargeInfo", updateOrderSchargeInfolist); 
		 }
		 
		 if(insertOrderSchargeListlist.size()!=0)
		 {
		 insertmap.put("OrderSchargeList", insertOrderSchargeListlist);
		 }
		 if(deleteOrderSchargeListlist.size()!=0)
		 {
		 deletemap.put("OrderSchargeList", deleteOrderSchargeListlist); 
		 }
		 if(updateOrderSchargeListlist.size()!=0)
		 {
		 updatemap.put("OrderSchargeList", updateOrderSchargeListlist); 
		 }
		 
		 if(insertOrderSpaymentInfolist.size()!=0)
		 {
		 insertmap.put("OrderSpaymentInfo", insertOrderSpaymentInfolist);
		 }
		 if(deleteOrderSpaymentInfolist.size()!=0)
		 {
		 deletemap.put("OrderSpaymentInfo", deleteOrderSpaymentInfolist); 
		 }
		 if(updateOrderSpaymentInfolist.size()!=0)
		 {
		 updatemap.put("OrderSpaymentInfo", updateOrderSpaymentInfolist); 
		 }
		 
		 if(insertOrderSpaymentListlist.size()!=0)
		 {
		 insertmap.put("OrderSpaymentList", insertOrderSpaymentListlist);
		 }
		 if(deleteOrderSpaymentListlist.size()!=0)
		 {
		 deletemap.put("OrderSpaymentList", deleteOrderSpaymentListlist); 
		 }
		 if(updateOrderSpaymentListlist.size()!=0)
		 {
		 updatemap.put("OrderSpaymentList", updateOrderSpaymentListlist); 
		 }
		 
		 if(insertSysAuthorityItemlist.size()!=0)
		 {
		 insertmap.put("SysAuthorityItem", insertSysAuthorityItemlist);
		 }
		 if(deleteSysAuthorityItemlist.size()!=0)
		 {
		 deletemap.put("SysAuthorityItem", deleteSysAuthorityItemlist); 
		 }
		 if(updateSysAuthorityItemlist.size()!=0)
		 {
		 updatemap.put("SysAuthorityItem", updateSysAuthorityItemlist); 
		 }
		 
		 if(insertSysBackupHistorylist.size()!=0)
		 {
		 insertmap.put("SysBackupHistory", insertSysBackupHistorylist);
		 }
		 if(deleteSysBackupHistorylist.size()!=0)
		 {
		 deletemap.put("SysBackupHistory", deleteSysBackupHistorylist); 
		 }
		 if(updateSysBackupHistorylist.size()!=0)
		 {
		 updatemap.put("SysBackupHistory", updateSysBackupHistorylist); 
		 }
		 
		 if(insertSysBusinessTableslist.size()!=0)
		 {
		 insertmap.put("SysBusinessTables", insertSysBusinessTableslist);
		 }
		 if(deleteSysBusinessTableslist.size()!=0)
		 {
		 deletemap.put("SysBusinessTables", deleteSysBusinessTableslist); 
		 }
		 if(updateSysBusinessTableslist.size()!=0)
		 {
		 updatemap.put("SysBusinessTables", updateSysBusinessTableslist); 
		 }
		 
		 if(insertSysCashAuthorityItemlist.size()!=0)
		 {
		 insertmap.put("SysCashAuthorityItem", insertSysCashAuthorityItemlist);
		 }
		 if(deleteSysCashAuthorityItemlist.size()!=0)
		 {
		 deletemap.put("SysCashAuthorityItem", deleteSysCashAuthorityItemlist); 
		 }
		 if(updateSysCashAuthorityItemlist.size()!=0)
		 {
		 updatemap.put("SysCashAuthorityItem", updateSysCashAuthorityItemlist); 
		 }
		 
		 if(insertSysCashuserlist.size()!=0)
		 {
		 insertmap.put("SysCashuser", insertSysCashuserlist);
		 }
		 if(deleteSysCashuserlist.size()!=0)
		 {
		 deletemap.put("SysCashuser", deleteSysCashuserlist); 
		 }
		 if(updateSysCashuserlist.size()!=0)
		 {
		 updatemap.put("SysCashuser", updateSysCashuserlist); 
		 }
		 
		 if(insertSysCheckuserInfolist.size()!=0)
		 {
		 insertmap.put("SysCheckuserInfo", insertSysCheckuserInfolist);
		 }
		 if(deleteSysCheckuserInfolist.size()!=0)
		 {
		 deletemap.put("SysCheckuserInfo", deleteSysCheckuserInfolist); 
		 }
		 if(updateSysCheckuserInfolist.size()!=0)
		 {
		 updatemap.put("SysCheckuserInfo", updateSysCheckuserInfolist); 
		 }
		 
		 if(insertSysFieldNameDefslist.size()!=0)
		 {
		 insertmap.put("SysFieldNameDefs", insertSysFieldNameDefslist);
		 }
		 if(deleteSysFieldNameDefslist.size()!=0)
		 {
		 deletemap.put("SysFieldNameDefs", deleteSysFieldNameDefslist); 
		 }
		 if(updateSysFieldNameDefslist.size()!=0)
		 {
		 updatemap.put("SysFieldNameDefs", updateSysFieldNameDefslist); 
		 }
		
		 if(insertSysLogDtllist.size()!=0)
		 {
		 insertmap.put("SysLogDtl", insertSysLogDtllist);
		 }
		 if(deleteSysLogDtllist.size()!=0)
		 {
		 deletemap.put("SysLogDtl", deleteSysLogDtllist); 
		 }
		 if(updateSysLogDtllist.size()!=0)
		 {
		 updatemap.put("SysLogDtl", updateSysLogDtllist); 
		 }
		 
		 if(insertSysLogFieldslist.size()!=0)
		 {
		 insertmap.put("SysLogFields", insertSysLogFieldslist);
		 }
		 if(deleteSysLogFieldslist.size()!=0)
		 {
		 deletemap.put("SysLogFields", deleteSysLogFieldslist); 
		 }
		 if(updateSysLogFieldslist.size()!=0)
		 {
		 updatemap.put("SysLogFields", updateSysLogFieldslist); 
		 }
		 
		 if(insertSysLoginCashLoglist.size()!=0)
		 {
		 insertmap.put("SysLoginCashLog", insertSysLoginCashLoglist);
		 }
		 if(deleteSysLoginCashLoglist.size()!=0)
		 {
		 deletemap.put("SysLoginCashLog", deleteSysLoginCashLoglist); 
		 }
		 if(updateSysLoginCashLoglist.size()!=0)
		 {
		 updatemap.put("SysLoginCashLog", updateSysLoginCashLoglist); 
		 }
		 
		 if(insertSysLoginLoglist.size()!=0)
		 {
		 insertmap.put("SysLoginLog", insertSysLoginLoglist);
		 }
		 if(deleteSysLoginLoglist.size()!=0)
		 {
		 deletemap.put("SysLoginLog", deleteSysLoginLoglist); 
		 }
		 if(updateSysLoginLoglist.size()!=0)
		 {
		 updatemap.put("SysLoginLog", updateSysLoginLoglist); 
		 }
		 
		 if(insertSysLoglist.size()!=0)
		 {
		 insertmap.put("SysLog", insertSysLoglist);
		 }
		 if(deleteSysLoglist.size()!=0)
		 {
		 deletemap.put("SysLog", deleteSysLoglist); 
		 }
		 if(updateSysLoglist.size()!=0)
		 {
		 updatemap.put("SysLog", updateSysLoglist); 
		 }
		 
		 if(insertSysModuleslist.size()!=0)
		 {
		 insertmap.put("SysModules", insertSysModuleslist);
		 }
		 if(deleteSysModuleslist.size()!=0)
		 {
		 deletemap.put("SysModules", deleteSysModuleslist); 
		 }
		 if(updateSysModuleslist.size()!=0)
		 {
		 updatemap.put("SysModules", updateSysModuleslist); 
		 }
		 
		 if(insertSysMyformActionCustomNamelist.size()!=0)
		 {
		 insertmap.put("SysMyformActionCustomName", insertSysMyformActionCustomNamelist);
		 }
		 if(deleteSysMyformActionCustomNamelist.size()!=0)
		 {
		 deletemap.put("SysMyformActionCustomName", deleteSysMyformActionCustomNamelist); 
		 }
		 if(updateSysMyformActionCustomNamelist.size()!=0)
		 {
		 updatemap.put("SysMyformActionCustomName", updateSysMyformActionCustomNamelist); 
		 }
		 
		 if(insertSysMymenulist.size()!=0)
		 {
		 insertmap.put("SysMymenu", insertSysMymenulist);
		 }
		 if(deleteSysMymenulist.size()!=0)
		 {
		 deletemap.put("SysMymenu", deleteSysMymenulist); 
		 }
		 if(updateSysMymenulist.size()!=0)
		 {
		 updatemap.put("SysMymenu", updateSysMymenulist); 
		 } 
		 
		 if(insertSysMyuserlist.size()!=0)
		 {
		 insertmap.put("SysMyuser", insertSysMyuserlist);
		 }
		 if(deleteSysMyuserlist.size()!=0)
		 {
		 deletemap.put("SysMyuser", deleteSysMyuserlist); 
		 }
		 if(updateSysMyuserlist.size()!=0)
		 {
		 updatemap.put("SysMyuser", updateSysMyuserlist); 
		 }
		 
		 if(insertSysMyuserGrouplist.size()!=0)
		 {
		 insertmap.put("SysMyuserGroup", insertSysMyuserGrouplist);
		 }
		 if(deleteSysMyuserGrouplist.size()!=0)
		 {
		 deletemap.put("SysMyuserGroup", deleteSysMyuserGrouplist); 
		 }
		 if(updateSysMyuserGrouplist.size()!=0)
		 {
		 updatemap.put("SysMyuserGroup", updateSysMyuserGrouplist); 
		 }
		 
		 if(insertSysMyuserGroupRelist.size()!=0)
		 {
		 insertmap.put("SysMyuserGroupRe", insertSysMyuserGroupRelist);
		 }
		 if(deleteSysMyuserGroupRelist.size()!=0)
		 {
		 deletemap.put("SysMyuserGroupRe", deleteSysMyuserGroupRelist); 
		 }
		 if(updateSysMyuserGroupRelist.size()!=0)
		 {
		 updatemap.put("SysMyuserGroupRe", updateSysMyuserGroupRelist); 
		 }
		 
		 if(insertSysMyuserRolelist.size()!=0)
		 {
		 insertmap.put("SysMyuserRole", insertSysMyuserRolelist);
		 }
		 if(deleteSysMyuserRolelist.size()!=0)
		 {
		 deletemap.put("SysMyuserRole", deleteSysMyuserRolelist); 
		 }
		 if(updateSysMyuserRolelist.size()!=0)
		 {
		 updatemap.put("SysMyuserRole", updateSysMyuserRolelist); 
		 }
		 
		 if(insertbaseLadderPriceLoglist.size()!=0)
		 {
		 insertmap.put("baseLadderPriceLog", insertbaseLadderPriceLoglist);
		 }
		 if(deletebaseLadderPriceLoglist.size()!=0)
		 {
		 deletemap.put("baseLadderPriceLog", deletebaseLadderPriceLoglist); 
		 }
		 if(updatebaseLadderPriceLoglist.size()!=0)
		 {
		 updatemap.put("baseLadderPriceLog", updatebaseLadderPriceLoglist); 
		 }
		 
		 if(insertbaseLadderPricelist.size()!=0)
		 {
		 insertmap.put("baseLadderPrice", insertbaseLadderPricelist);
		 }
		 if(deletebaseLadderPricelist.size()!=0)
		 {
		 deletemap.put("baseLadderPrice", deletebaseLadderPricelist); 
		 }
		 if(updatebaseLadderPricelist.size()!=0)
		 {
		 updatemap.put("baseLadderPrice", updatebaseLadderPricelist); 
		 }
		 
		 if(insertbaseMemberdaylist.size()!=0)
		 {
		 insertmap.put("baseMemberday", insertbaseMemberdaylist);
		 }
		 if(deletebaseMemberdaylist.size()!=0)
		 {
		 deletemap.put("baseMemberday", deletebaseMemberdaylist); 
		 }
		 if(updatebaseMemberdaylist.size()!=0)
		 {
		 updatemap.put("baseMemberday", updatebaseMemberdaylist); 
		 }
		 
		 if(insertBaseMonthlyBalancelist.size()!=0)
		 {
		 insertmap.put("BaseMonthlyBalance", insertBaseMonthlyBalancelist);
		 }
		 if(deleteBaseMonthlyBalancelist.size()!=0)
		 {
		 deletemap.put("BaseMonthlyBalance", deleteBaseMonthlyBalancelist); 
		 }
		 if(updateBaseMonthlyBalancelist.size()!=0)
		 {
		 updatemap.put("BaseMonthlyBalance", updateBaseMonthlyBalancelist); 
		 }
		 
		 if(insertBaseMultiItemlist.size()!=0)
		 {
		 insertmap.put("BaseMultiItem", insertBaseMultiItemlist);
		 }
		 if(deleteBaseMultiItemlist.size()!=0)
		 {
		 deletemap.put("BaseMultiItem", deleteBaseMultiItemlist); 
		 }
		 if(updateBaseMultiItemlist.size()!=0)
		 {
		 updatemap.put("BaseMultiItem", updateBaseMultiItemlist); 
		 }
		 
		 if(insertOrderInstockInfolist.size()!=0)
		 {
		 insertmap.put("OrderInstockInfo", insertOrderInstockInfolist);
		 }
		 if(deleteOrderInstockInfolist.size()!=0)
		 {
		 deletemap.put("OrderInstockInfo", deleteOrderInstockInfolist); 
		 }
		 if(updateOrderInstockInfolist.size()!=0)
		 {
		 updatemap.put("OrderInstockInfo", updateOrderInstockInfolist); 
		 }
		 
		 if(insertOrderInstockGoodslist.size()!=0)
		 {
		 insertmap.put("OrderInstockGoods", insertOrderInstockGoodslist);
		 }
		 if(deleteOrderInstockGoodslist.size()!=0)
		 {
		 deletemap.put("OrderInstockGoods", deleteOrderInstockGoodslist); 
		 }
		 if(updateOrderInstockGoodslist.size()!=0)
		 {
		 updatemap.put("OrderInstockGoods", updateOrderInstockGoodslist); 
		 }
		 		 
		 if(insertOrderPurchaseGoodslist.size()!=0)
		 {
		 insertmap.put("OrderPurchaseGoods", insertOrderPurchaseGoodslist);
		 }
		 if(deleteOrderPurchaseGoodslist.size()!=0)
		 {
		 deletemap.put("OrderPurchaseGoods", deleteOrderPurchaseGoodslist); 
		 }
		 if(updateOrderPurchaseGoodslist.size()!=0)
		 {
		 updatemap.put("OrderPurchaseGoods", updateOrderPurchaseGoodslist); 
		 }
		 
		 if(insertOrderPurchaseInfolist.size()!=0)
		 {
		 insertmap.put("OrderPurchaseInfo", insertOrderPurchaseInfolist);
		 }
		 if(deleteOrderPurchaseInfolist.size()!=0)
		 {
		 deletemap.put("OrderPurchaseInfo", deleteOrderPurchaseInfolist); 
		 }
		 if(updateOrderPurchaseInfolist.size()!=0)
		 {
		 updatemap.put("OrderPurchaseInfo", updateOrderPurchaseInfolist); 
		 }
		 
		 if(insertBaseSupplierInfolist.size()!=0)
		 {
		 insertmap.put("BaseSupplierInfo", insertBaseSupplierInfolist);
		 }
		 if(deleteBaseSupplierInfolist.size()!=0)
		 {
		 deletemap.put("BaseSupplierInfo", deleteBaseSupplierInfolist); 
		 }
		 if(updateBaseSupplierInfolist.size()!=0)
		 {
		 updatemap.put("BaseSupplierInfo", updateBaseSupplierInfolist); 
		 }
		 
		 if(insertBasePromotionInfoLoglist.size()!=0)
		 {
		 insertmap.put("BasePromotionInfoLog", insertBasePromotionInfoLoglist);
		 }
		 if(deleteBasePromotionInfoLoglist.size()!=0)
		 {
		 deletemap.put("BasePromotionInfoLog", deleteBasePromotionInfoLoglist); 
		 }
		 if(updateBasePromotionInfoLoglist.size()!=0)
		 {
		 updatemap.put("BasePromotionInfoLog", updateBasePromotionInfoLoglist); 
		 }
		 
		 if(insertBasePromotionInfolist.size()!=0)
		 {
		 insertmap.put("BasePromotionInfo", insertBasePromotionInfolist);
		 }
		 if(deleteBasePromotionInfolist.size()!=0)
		 {
		 deletemap.put("BasePromotionInfo", deleteBasePromotionInfolist); 
		 }
		 if(updateBasePromotionInfolist.size()!=0)
		 {
		 updatemap.put("BasePromotionInfo", updateBasePromotionInfolist); 
		 }
		 
		 if(insertBaseVouchersLoglist.size()!=0)
		 {
		 insertmap.put("BaseVouchersLog", insertBaseVouchersLoglist);
		 }
		 if(deleteBaseVouchersLoglist.size()!=0)
		 {
		 deletemap.put("BaseVouchersLog", deleteBaseVouchersLoglist); 
		 }
		 if(updateBaseVouchersLoglist.size()!=0)
		 {
		 updatemap.put("BaseVouchersLog", updateBaseVouchersLoglist); 
		 }
		 
		 if(insertBaseVoucherslist.size()!=0)
		 {
		 insertmap.put("BaseVouchers", insertBaseVoucherslist);
		 }
		 if(deleteBaseVoucherslist.size()!=0)
		 {
		 deletemap.put("BaseVouchers", deleteBaseVoucherslist); 
		 }
		 if(updateBaseVoucherslist.size()!=0)
		 {
		 updatemap.put("BaseVouchers", updateBaseVoucherslist); 
		 }
		 
		 if(insertDailyGoodsInfolist.size()!=0)
		 {
		 insertmap.put("DailyGoodsInfo", insertDailyGoodsInfolist);
		 }
		 if(deleteDailyGoodsInfolist.size()!=0)
		 {
		 deletemap.put("DailyGoodsInfo", deleteDailyGoodsInfolist); 
		 }
		 if(updateDailyGoodsInfolist.size()!=0)
		 {
		 updatemap.put("DailyGoodsInfo", updateDailyGoodsInfolist); 
		 }
		 
		 if(insertDailyGoodstypeInfolist.size()!=0)
		 {
		 insertmap.put("DailyGoodstypeInfo", insertDailyGoodstypeInfolist);
		 }
		 if(deleteDailyGoodstypeInfolist.size()!=0)
		 {
		 deletemap.put("DailyGoodstypeInfo", deleteDailyGoodstypeInfolist); 
		 }
		 if(updateDailyGoodstypeInfolist.size()!=0)
		 {
		 updatemap.put("DailyGoodstypeInfo", updateDailyGoodstypeInfolist); 
		 }
		 
		 if(insertDailySaleamountInfolist.size()!=0)
		 {
		 insertmap.put("DailySaleamountInfo", insertDailySaleamountInfolist);
		 }
		 if(deleteDailySaleamountInfolist.size()!=0)
		 {
		 deletemap.put("DailySaleamountInfo", deleteDailySaleamountInfolist); 
		 }
		 if(updateDailySaleamountInfolist.size()!=0)
		 {
		 updatemap.put("DailySaleamountInfo", updateDailySaleamountInfolist); 
		 }
		 
		 if(insertDailySuppliersaleInfolist.size()!=0)
		 {
		 insertmap.put("DailySuppliersaleInfo", insertDailySuppliersaleInfolist);
		 }
		 if(deleteDailySuppliersaleInfolist.size()!=0)
		 {
		 deletemap.put("DailySuppliersaleInfo", deleteDailySuppliersaleInfolist); 
		 }
		 if(updateDailySuppliersaleInfolist.size()!=0)
		 {
		 updatemap.put("DailySuppliersaleInfo", updateDailySuppliersaleInfolist); 
		 }
		
		 if(insertMonlyGoodsInfolist.size()!=0)
		 {
		 insertmap.put("MonlyGoodsInfo", insertMonlyGoodsInfolist);
		 }
		 if(deleteMonlyGoodsInfolist.size()!=0)
		 {
		 deletemap.put("MonlyGoodsInfo", deleteMonlyGoodsInfolist); 
		 }
		 if(updateMonlyGoodsInfolist.size()!=0)
		 {
		 updatemap.put("MonlyGoodsInfo", updateMonlyGoodsInfolist); 
		 }
		 
		 if(insertMonlyGoodsTypelist.size()!=0)
		 {
		 insertmap.put("MonlyGoodsType", insertMonlyGoodsTypelist);
		 }
		 if(deleteMonlyGoodsTypelist.size()!=0)
		 {
		 deletemap.put("MonlyGoodsType", deleteMonlyGoodsTypelist); 
		 }
		 if(updateMonlyGoodsTypelist.size()!=0)
		 {
		 updatemap.put("MonlyGoodsType", updateMonlyGoodsTypelist); 
		 }
		 
		 if(insertMonlySaleamountInfolist.size()!=0)
		 {
		 insertmap.put("MonlySaleamountInfo", insertMonlySaleamountInfolist);
		 }
		 if(deleteMonlySaleamountInfolist.size()!=0)
		 {
		 deletemap.put("MonlySaleamountInfo", deleteMonlySaleamountInfolist); 
		 }
		 if(updateMonlySaleamountInfolist.size()!=0)
		 {
		 updatemap.put("MonlySaleamountInfo", updateMonlySaleamountInfolist); 
		 }
		 
		 if(insertMonlySuppliersaleInfolist.size()!=0)
		 {
		 insertmap.put("MonlySuppliersaleInfo", insertMonlySuppliersaleInfolist);
		 }
		 if(deleteMonlySuppliersaleInfolist.size()!=0)
		 {
		 deletemap.put("MonlySuppliersaleInfo", deleteMonlySuppliersaleInfolist); 
		 }
		 if(updateMonlySuppliersaleInfolist.size()!=0)
		 {
		 updatemap.put("MonlySuppliersaleInfo", updateMonlySuppliersaleInfolist); 
		 }
		 
		 if(insertOrderInstockModifyLoglist.size()!=0)
		 {
		 insertmap.put("OrderInstockModifyLog", insertOrderInstockModifyLoglist);
		 }
		 if(deleteOrderInstockModifyLoglist.size()!=0)
		 {
		 deletemap.put("OrderInstockModifyLog", deleteOrderInstockModifyLoglist); 
		 }
		 if(updateOrderInstockModifyLoglist.size()!=0)
		 {
		 updatemap.put("OrderInstockModifyLog", updateOrderInstockModifyLoglist); 
		 }
		 
		//endregion
		
		 
		 //FIXME 
		 
		
		 
		 
		 
		 Map<String,Map> map=new HashMap<String, Map>();
		 if(insertmap.size()!=0)
		 map.put("insertmap", insertmap);
		 if(deletemap.size()!=0)
		 map.put("deletemap", deletemap);
		 if(updatemap.size()!=0)
		 map.put("updatemap", updatemap);
		 
		System.out.println(map);
		if(map==null||map.size()==0)
		{
			System.out.println("没有要上传的数据包");
		}
		else{
			ObjectMapper mapper=new ObjectMapper();
	        String json1=mapper.writeValueAsString(map);
	        String json=URLEncoder.encode(json1, "utf-8"); //url 转码
	        //String json=new String(json1.getBytes("utf-8"),"utf-8"); 

	        //传入server 
	        try{
	         String jilubao=json1;
	         sZjilubiao jilu=new sZjilubiao();
	         jilu.setJilubao(jilubao);
	         Date now = new Date(); 
			 SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");//可以方便地修改日期格式
			 String tongbutime = dateFormat.format(now); 
			 jilu.setTongbutime(tongbutime);
	         sZjilubiaoService.insertSelective(jilu);
	         	        		
	        SyncClientclasssController.httpClientToServerPOST(json);
	        //遍历将同步表中，已经同步的数据修改状态
			 for(int j=0;j<size;j++)	
			 {
				 int tongbuid=tlist.get(j).getId();
				  Service.updateState(tongbuid);  
			 }
	        }
	        catch (Exception e)
	        {
	        	System.out.println("访问主服务器出错！！");
	        }
		}
		
        //访问服务器查询是否有要同步下来的的数据
		  //用于记录同步情况
		 String chaoshi0=xinxi.getSupermarketname();
		 String chaoshi=URLEncoder.encode(chaoshi0,"utf-8");
        String syncbao=SyncServerclasssController.httpServerToClientPOST(ming,chaoshi);
       // System.out.println("@@@@@@@@@"+syncbao);
        String bao1 = URLDecoder.decode(syncbao,"UTF-8");
        String bao = URLDecoder.decode(bao1,"UTF-8");
       // System.out.println("#########"+bao);
       
        if("no\r\n".equals(bao)||"".equals(bao))
        {
        	System.out.println("没有网上更新");
        }
        else
        {
        	ObjectMapper mapper=new ObjectMapper();	    
    		Map<String, Map<String,List>> servermap = mapper.readValue(bao, Map.class);
    		
    		
    		if(servermap.get("insertmap")!=null)
    		{
    			if(servermap.get("insertmap").get("BaseSupplierInfo")!=null)
    			{
    				for(int i=0;i<servermap.get("insertmap").get("BaseSupplierInfo").size();i++)
    				{
    					String ii= mapper.writeValueAsString(servermap.get("insertmap").get("BaseSupplierInfo").get(i));
    					BaseSupplierInfo iif=mapper.readValue(ii,BaseSupplierInfo.class);
    					iif.setId(null);
    					sBaseSupplierInfoService.insert(iif);    				    				
    				}
    			}
    			if(servermap.get("insertmap").get("OrderPurchaseGoods")!=null)
    			{
    				for(int i=0;i<servermap.get("insertmap").get("OrderPurchaseGoods").size();i++)
    				{
    					String ii= mapper.writeValueAsString(servermap.get("insertmap").get("OrderPurchaseGoods").get(i));
    					OrderPurchaseGoods iif=mapper.readValue(ii,OrderPurchaseGoods.class);
    					iif.setId(null);
    					sOrderPurchaseGoodsService.insert(iif);    				    				
    				}
    			}
    			if(servermap.get("insertmap").get("OrderPurchaseInfo")!=null)
    			{
    				for(int i=0;i<servermap.get("insertmap").get("OrderPurchaseInfo").size();i++)
    				{
    					String ii= mapper.writeValueAsString(servermap.get("insertmap").get("OrderPurchaseInfo").get(i));
    					OrderPurchaseInfo iif=mapper.readValue(ii,OrderPurchaseInfo.class);
    					iif.setId(null);
    					sOrderPurchaseInfoService.insert(iif);    				    				
    				}
    			}
    			if(servermap.get("insertmap").get("OrderInstockInfo")!=null)
    			{
    				for(int i=0;i<servermap.get("insertmap").get("OrderInstockInfo").size();i++)
    				{
    					String ii= mapper.writeValueAsString(servermap.get("insertmap").get("OrderInstockInfo").get(i));
    					OrderInstockInfo iif=mapper.readValue(ii,OrderInstockInfo.class);
    					iif.setId(null);
    					sOrderInstockInfoService.insert(iif);    				    				
    				}
    			}
    			if(servermap.get("insertmap").get("OrderInstockGoods")!=null)
    			{
    				for(int i=0;i<servermap.get("insertmap").get("OrderInstockGoods").size();i++)
    				{
    					String ii= mapper.writeValueAsString(servermap.get("insertmap").get("OrderInstockGoods").get(i));
    					OrderInstockGoods iif=mapper.readValue(ii,OrderInstockGoods.class);
    					iif.setId(null);
    					sOrderInstockGoodsService.insert(iif);    				    				
    				}
    			}
    			if(servermap.get("insertmap").get("BaseGoodsStock")!=null)
    			{
    				for(int i=0;i<servermap.get("insertmap").get("BaseGoodsStock").size();i++)
    				{
    					String ii= mapper.writeValueAsString(servermap.get("insertmap").get("BaseGoodsStock").get(i));
    					BaseGoodsStock iif=mapper.readValue(ii,BaseGoodsStock.class);    					
    					iif.setId(null);
    					sBaseGoodsStockService.insert(iif);    				    				
    				}
    			}
    			if(servermap.get("insertmap").get("BaseMemberInfo")!=null)
    			{
    				for(int i=0;i<servermap.get("insertmap").get("BaseMemberInfo").size();i++)
    				{
    					String ii= mapper.writeValueAsString(servermap.get("insertmap").get("BaseMemberInfo").get(i));
    					BaseMemberInfo iif=mapper.readValue(ii,BaseMemberInfo.class);    					
    					iif.setMid(null);
    					 sBaseMemberInfoService.insert(iif);    				    				
    				}
    			}
    			if(servermap.get("insertmap").get("BaseValuecardInfo")!=null)
    			{
    				for(int i=0;i<servermap.get("insertmap").get("BaseValuecardInfo").size();i++)
    				{
    					String ii= mapper.writeValueAsString(servermap.get("insertmap").get("BaseValuecardInfo").get(i));
    					BaseValuecardInfo iif=mapper.readValue(ii,BaseValuecardInfo.class);    					
    					iif.setId(null);
    					 sBaseValuecardInfoService.insert(iif);    				    				
    				}
    			}
    			
    		}
    		if(servermap.get("updatemap")!=null)
    		{
    			if(servermap.get("updatemap").get("BaseSupplierInfo")!=null)
    			{
    				for(int i=0;i<servermap.get("updatemap").get("BaseSupplierInfo").size();i++)
    				{
    					String ii= mapper.writeValueAsString(servermap.get("updatemap").get("BaseSupplierInfo").get(i));
    					BaseSupplierInfo iif=mapper.readValue(ii,BaseSupplierInfo.class);
    	                sBaseSupplierInfoService.updateInfo(iif);		       	      
    				}
    			}
    			if(servermap.get("updatemap").get("OrderPurchaseGoods")!=null)
    			{
    				for(int i=0;i<servermap.get("updatemap").get("OrderPurchaseGoods").size();i++)
    				{
    					String ii= mapper.writeValueAsString(servermap.get("updatemap").get("OrderPurchaseGoods").get(i));
    					OrderPurchaseGoods iif=mapper.readValue(ii,OrderPurchaseGoods.class);
    	                sOrderPurchaseGoodsService.updateInfo(iif);		       	      
    				}
    			}
    			if(servermap.get("updatemap").get("OrderPurchaseInfo")!=null)
    			{
    				for(int i=0;i<servermap.get("updatemap").get("OrderPurchaseInfo").size();i++)
    				{
    					String ii= mapper.writeValueAsString(servermap.get("updatemap").get("OrderPurchaseInfo").get(i));
    					OrderPurchaseInfo iif=mapper.readValue(ii,OrderPurchaseInfo.class);
    	                sOrderPurchaseInfoService.updateInfo(iif);		       	      
    				}
    			}
    			if(servermap.get("updatemap").get("OrderInstockInfo")!=null)
    			{
    				for(int i=0;i<servermap.get("updatemap").get("OrderInstockInfo").size();i++)
    				{
    					String ii= mapper.writeValueAsString(servermap.get("updatemap").get("OrderInstockInfo").get(i));
    					OrderInstockInfo iif=mapper.readValue(ii,OrderInstockInfo.class);
    	                sOrderInstockInfoService.updateInfo(iif);		       	      
    				}
    			}
    			if(servermap.get("updatemap").get("OrderInstockGoods")!=null)
    			{
    				for(int i=0;i<servermap.get("updatemap").get("OrderInstockGoods").size();i++)
    				{
    					String ii= mapper.writeValueAsString(servermap.get("updatemap").get("OrderInstockGoods").get(i));
    					OrderInstockGoods iif=mapper.readValue(ii,OrderInstockGoods.class);
    	                int iii=sOrderInstockGoodsService.updateInfo(iif);	
    	                System.out.println(iii);
    				}
    			}
    			if(servermap.get("updatemap").get("BaseGoodsStock")!=null)
    			{
    				for(int i=0;i<servermap.get("updatemap").get("BaseGoodsStock").size();i++)
    				{
    					String ii= mapper.writeValueAsString(servermap.get("updatemap").get("BaseGoodsStock").get(i));
    					BaseGoodsStock iif=mapper.readValue(ii,BaseGoodsStock.class);
    	                sBaseGoodsStockService.updateInfo(iif);		       	      
    				}
    			}
    			if(servermap.get("updatemap").get("BaseMemberInfo")!=null)
    			{
    				for(int i=0;i<servermap.get("updatemap").get("BaseMemberInfo").size();i++)
    				{
    					String ii= mapper.writeValueAsString(servermap.get("updatemap").get("BaseMemberInfo").get(i));
    					BaseMemberInfo iif=mapper.readValue(ii,BaseMemberInfo.class);
    	                sBaseMemberInfoService.updateInfo(iif);		       	      
    				}
    			}
    			if(servermap.get("updatemap").get("BaseValuecardInfo")!=null)
    			{
    				for(int i=0;i<servermap.get("updatemap").get("BaseValuecardInfo").size();i++)
    				{
    					String ii= mapper.writeValueAsString(servermap.get("updatemap").get("BaseValuecardInfo").get(i));
    					BaseValuecardInfo iif=mapper.readValue(ii,BaseValuecardInfo.class);
    	                sBaseValuecardInfoService.updateInfo(iif);		       	      
    				}
    			}
    			
    		}
    		if(servermap.get("deletemap")!=null)
    		{
	    			if(servermap.get("deletemap").get("BaseSupplierInfo")!=null)
	  			  {
	  				for(int i=0;i<servermap.get("deletemap").get("BaseSupplierInfo").size();i++)
	  				{
	  					String ii= mapper.writeValueAsString(servermap.get("deletemap").get("BaseSupplierInfo").get(i));
	  					BaseSupplierInfo iif=mapper.readValue(ii,BaseSupplierInfo.class);
	  					 sBaseSupplierInfoService.delete(iif);		
	  	                					
	  				}
	  			  }	
				if(servermap.get("deletemap").get("OrderPurchaseGoods")!=null)
				  {
					for(int i=0;i<servermap.get("deletemap").get("OrderPurchaseGoods").size();i++)
					{
						String ii= mapper.writeValueAsString(servermap.get("deletemap").get("OrderPurchaseGoods").get(i));
						OrderPurchaseGoods iif=mapper.readValue(ii,OrderPurchaseGoods.class);
						 sOrderPurchaseGoodsService.delete(iif);		
		                					
					}
				  }	
				if(servermap.get("deletemap").get("OrderPurchaseInfo")!=null)
				  {
					for(int i=0;i<servermap.get("deletemap").get("OrderPurchaseInfo").size();i++)
					{
						String ii= mapper.writeValueAsString(servermap.get("deletemap").get("OrderPurchaseInfo").get(i));
						OrderPurchaseInfo iif=mapper.readValue(ii,OrderPurchaseInfo.class);
						 sOrderPurchaseInfoService.delete(iif);		
		                					
					}
				  }	
	    			if(servermap.get("deletemap").get("OrderInstockInfo")!=null)
	  			  {
	  				for(int i=0;i<servermap.get("deletemap").get("OrderInstockInfo").size();i++)
	  				{
	  					String ii= mapper.writeValueAsString(servermap.get("deletemap").get("OrderInstockInfo").get(i));
	  					OrderInstockInfo iif=mapper.readValue(ii,OrderInstockInfo.class);
	  					 sOrderInstockInfoService.delete(iif);		
	  	                					
	  				}
	  			  }	
	    			if(servermap.get("deletemap").get("OrderInstockGoods")!=null)
		  			  {
		  				for(int i=0;i<servermap.get("deletemap").get("OrderInstockGoods").size();i++)
		  				{
		  					String ii= mapper.writeValueAsString(servermap.get("deletemap").get("OrderInstockGoods").get(i));
		  					OrderInstockGoods iif=mapper.readValue(ii,OrderInstockGoods.class);
		  					 sOrderInstockGoodsService.delete(iif);		
		  	                					
		  				}
		  			  }
	    			if(servermap.get("deletemap").get("BaseGoodsStock")!=null)
		  			  {
		  				for(int i=0;i<servermap.get("deletemap").get("BaseGoodsStock").size();i++)
		  				{
		  					String ii= mapper.writeValueAsString(servermap.get("deletemap").get("BaseGoodsStock").get(i));
		  					BaseGoodsStock iif=mapper.readValue(ii,BaseGoodsStock.class);
		  					 sBaseGoodsStockService.delete(iif);		
		  	                					
		  				}
		  			  }
	    			if(servermap.get("deletemap").get("BaseMemberInfo")!=null)
		  			  {
		  				for(int i=0;i<servermap.get("deletemap").get("BaseMemberInfo").size();i++)
		  				{
		  					String ii= mapper.writeValueAsString(servermap.get("deletemap").get("BaseMemberInfo").get(i));
		  					BaseMemberInfo iif=mapper.readValue(ii,BaseMemberInfo.class);
		  					 sBaseMemberInfoService.delete(iif);		
		  	                					
		  				}
		  			  }
	    			if(servermap.get("deletemap").get("BaseValuecardInfo")!=null)
		  			  {
		  				for(int i=0;i<servermap.get("deletemap").get("BaseValuecardInfo").size();i++)
		  				{
		  					String ii= mapper.writeValueAsString(servermap.get("deletemap").get("BaseValuecardInfo").get(i));
		  					BaseValuecardInfo iif=mapper.readValue(ii,BaseValuecardInfo.class);
		  					 sBaseValuecardInfoService.delete(iif);		
		  	                					
		  				}
		  			  }
    		
    		}
    		
        }
               
        /*List li=new ArrayList<Map>();
        li.add(map);
        extData.setList(li);*/
	 
		}
		
		}	
		
	  catch (Exception e) {  
           e.printStackTrace();  
          
       }
	   
	}
	
	public static boolean substractionDateGTROneHours(Date startDate,Date nowDate){

	    long betweenDays = (long)((nowDate.getTime() - startDate.getTime()) / (1000 * 60 * 60) + 0.5); 

	    if (betweenDays >= 12) {
			return true;
		}else{
			return false;
		}
	}

}
